0:\\n # if tweet has retweets, ensure that it is appended only once\\n if parsed_tweet not in tweets:\\n tweets.append(parsed_tweet)\\n else:\\n tweets.append(parsed_tweet)\\n\\n # return parsed tweets\\n return tweets\\n\\n except tweepy.TweepError as e:\\n # print error (if any)\\n print(\\\"Error : \\\" + str(e))\",\n \"def get_tweets():\\n clean_tweetdb.delay()\\n db_tweets = Tweet.objects.all()\\n max_id = min([tweet.tweet_id for tweet in db_tweets])\\n tweets = api.search(\\n q='#python',\\n max_id=max_id,\\n count=100\\n )\\n tweets_id = [tweet.id for tweet in tweets]\\n tweets_date = [tweet.created_at for tweet in tweets]\\n tweets_source = [tweet.source for tweet in tweets]\\n tweets_favorite_cnt = [tweet.favorite_count for tweet in tweets]\\n tweets_retweet_cnt = [tweet.retweet_count for tweet in tweets]\\n tweets_text = [tweet.text for tweet in tweets]\\n\\n for i, j, k, l, m, n in zip(\\n tweets_id,\\n tweets_date,\\n tweets_source,\\n tweets_favorite_cnt,\\n tweets_retweet_cnt,\\n tweets_text,\\n ):\\n try:\\n Tweet.objects.create(\\n tweet_id=i,\\n tweet_date=j,\\n tweet_source=k,\\n tweet_favorite_cnt=l,\\n tweet_retweet_cnt=m,\\n tweet_text=n,\\n )\\n except IntegrityError:\\n pass\",\n \"def get_tweets(self, kafka_obj):\\n\\n try:\\n\\n # call twitter api to fetch tweets\\n # for tweet in api.search('#machinelearning', count=5):\\n\\n for tweet in tweepy.Cursor(api.search, q='#machinelearning', since='2019-06-25', until='2019-07-07').items():\\n\\n # empty dictionary to store required params of a tweet\\n parsed_tweet = dict()\\n parsed_tweet['text'] = tweet.text\\n parsed_tweet['date'] = str(tweet.created_at)\\n parsed_tweet['sentiment'] = self.get_tweet_sentiment(tweet.text)\\n parsed_tweet['tweet_id'] = tweet.id_str\\n parsed_tweet['location'] = tweet.user.location\\n parsed_tweet['user'] = tweet.user.screen_name\\n parsed_tweet['retweet_count'] = tweet.retweet_count\\n\\n if tweet.entities.get('hashtags'):\\n parsed_tweet['hashtags'] = ', '.join([i['text'] for i in tweet.entities.get('hashtags')])\\n else:\\n parsed_tweet['hashtags'] = ''\\n \\n print('Search API', parsed_tweet)\\n\\n #Pushing all the tweets to the Kafka Topic\\n\\n kafka_producer = kafka_obj.producer_instance()\\n kafka_obj.publish_urls(kafka_producer, 'twitter', 'tweet', json.dumps(parsed_tweet))\\n\\n except Exception as e:\\n print(e)\",\n \"def twitter_get_timeline(self):\\n if self.twitter_bearer_token is None:\\n return None\\n\\n url = 'https://api.twitter.com/1.1/statuses/user_timeline.json?count=100&screen_name=' + \\\\\\n self.private_data['twitter']['screen_name']\\n\\n headers = {'Authorization': 'Bearer %s' % self.twitter_bearer_token,\\n 'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'}\\n\\n resp = requests.get(url, headers=headers)\\n tweets = []\\n if resp.status_code == 200:\\n content = json.loads(resp.content)\\n for i in range(0, len(content)):\\n tweets.append(content[i]['text'])\\n else:\\n print('ERROR: unable to retrieve timeline')\\n print(resp.content)\\n\\n return tweets\",\n \"def list_tweets():\\n tweets = []\\n tuples = query_db('''\\n select message.*, user.* from message, user\\n where message.author_id = user.user_id\\n order by message.pub_date desc limit ?''', [PER_PAGE])\\n for tuple in tuples:\\n tweet = {}\\n tweet[\\\"username\\\"] = tuple['username']\\n tweet[\\\"email\\\"] = tuple['email']\\n tweet[\\\"text\\\"] = tuple['text']\\n tweet[\\\"pub_date\\\"] = tuple['pub_date']\\n tweets.append(tweet)\\n return jsonify({'tweets':tweets}),200\",\n \"def get_tweets(n=1):\\n tweets = list(collection.find())[-n:]\\n return tweets\",\n \"def get_tweets(user, num = 200):\\n tweets = []\\n \\n for tweet in user.home_timeline(count = num):\\n edited_tweet = tweet.text\\n edited_tweet = edited_tweet.encode(encoding='UTF-8', errors='Ignore') \\n tweets.append(edited_tweet)\\n return tweets\",\n \"def get_tweets(self):\\r\\n return self.tweets\",\n \"def get_tweet_data(session, analytics_account, start_time, end_time, user_agent):\\n\\n export_url = \\\"https://analytics.twitter.com/user/\\\" + analytics_account + \\\"/tweets/export.json\\\"\\n bundle_url = \\\"https://analytics.twitter.com/user/\\\" + analytics_account + \\\"/tweets/bundle\\\"\\n\\n export_data = {\\n 'start_time' : end_time,\\n 'end_time' : start_time,\\n 'lang' : 'en'\\n }\\n querystring = '?' + urllib.parse.urlencode(export_data)\\n print('Querying Twitter...')\\n\\n\\n status = 'Pending'\\n counter = 0\\n while status == 'Pending':\\n attempt = session.post(export_url + querystring, headers=user_agent)\\n status_dict = json.loads(attempt.text)\\n status = status_dict['status']\\n counter += 1\\n print('Attempt:', counter, ' Response:',status)\\n time.sleep(5)\\n\\n csv_header = {'Content-Type': 'application/csv',\\n 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',\\n 'Accept-Encoding': 'gzip, deflate, sdch',\\n 'Accept-Language': 'en-US,en;q=0.8',\\n 'Upgrade-Insecure-Requests': '1',\\n 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36'}\\n\\n data_req = session.get(bundle_url + querystring, headers=csv_header)\\n #print(\\\"data_req response: \\\", data_req.status_code)\\n print(\\\"Data retrieved, appending dataset.\\\")\\n return data_req.text\",\n \"def get_tweets(keyword, max_tweets=200):\\n\\n # API keys.\\n consumer_key = \\\"kNOG1klRMMUYbsjMuY5TKl4lE\\\"\\n consumer_secret = \\\"ieghv6WI1qseYly43A0Ra1MPksEw1i5Onma0txfEu5aHantD2v\\\"\\n access_key = \\\"3291622062-15ssVc0qpJXf2SFXbA7vgfl1Sooz4Ueo2DGPQVz\\\"\\n access_secret = \\\"9XJuzgGSVLnx93tq6NfRzMT07S6o2lzjmHfjt3VRlkqXn\\\"\\n\\n # Initialize tweepy API object and authorize using API key.\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_key, access_secret)\\n api = tweepy.API(auth)\\n\\n \\\"\\\"\\\" Get tweets.\\\"\\\"\\\"\\n\\n alltweets = []\\n for status in tweepy.Cursor(\\n api.search,\\n q=keyword + \\\" -RT\\\", # the -RT flag excludes retweets.\\n count=1000,\\n result_type=\\\"recent\\\",\\n include_entities=True,\\n monitor_rate_limit=True,\\n wait_on_rate_limit=True,\\n lang=\\\"en\\\",\\n ).items():\\n\\n # get text of the tweet, encoding as utf-8.\\n text = str(status.text.encode(\\\"utf-8\\\"))\\n\\n # add to the data structure, alltweets, holding the tweets.\\n alltweets.append(text)\\n\\n # if we've reached max_tweets, break.\\n if len(alltweets) >= max_tweets:\\n break\\n\\n return alltweets\",\n \"def searchTweets():\\n if 'api' not in globals():\\n startTwitterApi(getApiKeys(fileName='apiConf2.txt'))\\n #SEARCHING TWEETS CONTAINING THE HASHTAG \\\"#bitcoin\\\" USING TWEEPY LIBRARY\\n myTweets= []\\n #words=list(map(str,words))\\n if words:\\n myQuery=' OR '.join(words)\\n else:\\n myQuery = '*'\\n if removeRetweets:\\n myQuery += ' - filter:retweets'\\n kwargs['q']=myQuery\\n kwargs['count']=100\\n kwargs['tweet_mode']='extended'\\n if 'startingDate' in kwargs:\\n kwargs['since']=kwargs['startingDate']\\n del(kwargs['startingDate'])\\n if 'endingDate' in kwargs:\\n kwargs['until']=kwargs['endingDate']\\n del(kwargs['endingDate'])\\n if 'maxTweets' in kwargs:\\n del(kwargs['maxTweets'])\\n if sortBy=='newest':\\n for tweet in tweepy.Cursor(api.search, kwargs).items(maxTweets):\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n else:\\n for tweet in tweepy.Cursor(api.search, kwargs).items():\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n return getTopNTweets(myTweets, maxTweets)\",\n \"def get_list_of_rts():\\n # Get all tweets, up to 3200 tweets\\n tweets = []\\n max_tweet_count = 3200\\n count_per_request = 200\\n batch_min = None\\n batch_max_arg = \\\"\\\"\\n for i in range(max_tweet_count // count_per_request):\\n # TODO: move get user timeline with continuation in its own function\\n r = requests.get(twitter_api_base +\\n \\\"/statuses/user_timeline.json?count=%d&exclude_replies=true&include_rts=true%s\\\" % (count_per_request, batch_max_arg),\\n auth=oauth_credentials)\\n if r.status_code != 200:\\n received_error(r)\\n break\\n batch = json.loads(r.text)\\n for tweet in batch:\\n if 'retweeted_status' in tweet:\\n tweets.append(tweet)\\n if 'id' in tweet:\\n # we don't use min(batch, key=lambda x: x['id']) because it\\n # would require us to go through the list two times\\n if batch_min == None:\\n batch_min = tweet['id']\\n else:\\n batch_min = min(batch_min, tweet['id'])\\n print(\\\"Batch length: %d, min tweet id: %s\\\" % (len(batch), batch_min))\\n if len(batch) <= 1:\\n break\\n batch_max_arg = \\\"&max_id=%d\\\" % batch_min\\n return tweets\",\n \"def extract_tweets(consumer_key,consumer_secret,access_token,access_token_secret,search_key):\\n # Step 1 - Authenticate\\n consumer_key= str(consumer_key)\\n consumer_secret= str(consumer_secret)\\n\\n access_token=str(access_token)\\n access_token_secret=str(access_token_secret)\\n\\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret)\\n auth.set_access_token(access_token, access_token_secret)\\n\\n api = tweepy.API(auth)\\n\\n #Step 3 - Retrieve Tweets\\n public_tweets = api.search(search_key)\\n tweets_list=[]\\n for tweet in public_tweets:\\n tweets_list.append(tweet.text)\\n return tweets_list\",\n \"def streamTweets(words = [], authors = [], timeLimit=120, removeRetweets=False, **kwargs):\\n if 'stream' not in globals():\\n global stream\\n if 'api' not in globals():\\n startTwitterApi(getApiKeys(fileName=\\\"apiConf2.txt\\\"))\\n listener = StdOutListener(removeRetweets=removeRetweets)\\n auth = api.auth\\n stream = tweepy.Stream(auth, listener, tweet_mode='extended')\\n else:\\n stream.listener.setRemoveRetweets(removeRetweets)\\n stream.listener.resetTweets()\\n\\n words = mapToValid(words)\\n authors = mapToValid(authors)\\n if not words and not authors:\\n words=[\\\"the\\\", \\\"i\\\", \\\"to\\\", \\\"a\\\", \\\"and\\\", \\\"'s\\\", \\\"is\\\", \\\"in\\\", \\\"it\\\", \\\"you\\\", \\\"of\\\", \\\"for\\\", \\\"on\\\", \\\"my\\\", \\\"that\\\", \\\"e\\\", \\\"with\\\", \\\"me\\\", \\\"do\\\", \\\"have\\\", \\\"ciao\\\", \\\"o\\\", \\\"u\\\", \\\"cool\\\", \\\"good\\\", \\\"nice\\\", \\\"#\\\", \\\"*\\\", \\\":\\\", \\\";\\\", \\\",\\\", \\\".\\\", \\\"?\\\", \\\"-\\\", \\\"%\\\", \\\"$\\\", \\\"€\\\", \\\"!\\\", \\\"(\\\", \\\")\\\", \\\"=\\\", \\\"'\\\"]\\n\\n #myQuery = ' OR '.join(kwargs[\\\"words\\\"])\\n if authors:\\n kwargs[\\\"follow\\\"]=[user.id_str for user in list(map(api.get_user,authors))]\\n else:\\n kwargs[\\\"track\\\"]=words\\n #if removeRetweets:\\n # myQuery += \\\" -filter:retweets\\\"\\n\\n #myQuery += ' from:'\\n #myQuery += ' OR from:'.join(kwargs[\\\"authors\\\"])\\n #print(myQuery)\\n import signal\\n # Register the signal function handler\\n signal.signal(signal.SIGALRM, __streamHandler__)\\n # Define a timeout for your function\\n signal.alarm(timeLimit)\\n try:\\n __stream__(stream,**kwargs)\\n except Exception:\\n print(\\\"Streaming over after time period of\\\", timeLimit, \\\"seconds... Retrieved\\\", len(stream.listener.getTweets()), \\\"tweets.\\\")\\n stream.disconnect()\\n if authors and words:\\n print(\\\"Filtering out tweets that don't contain the specified words...\\\")\\n myTweets=[]\\n for tweet in stream.listener.getTweets():\\n if 'full_text' in tweet:\\n tweet['text'] = tweet['full_text']\\n del (tweet['full_text'])\\n if any(containsWord(tweet['text'],word) for word in words):\\n myTweets.append(tweet)\\n print(\\\"Done. Retrieved\\\", len(myTweets), \\\"tweets written by the authors specified and containing (any of) the words specified.\\\")\\n return myTweets\\n return stream.listener.getTweets()\",\n \"def get_tweets(twitter, screen_name, num_tweets):\\n\\n request = robust_request(twitter, 'search/tweets', {'q': screen_name, 'count': num_tweets})\\n tweets = [a['text'] for a in request]\\n\\n return tweets\",\n \"def get_tweets_count_times(twitter, count, query=None):\\n # get id to start from\\n oldest_id, newest_id = _get_oldest_id(query=query)\\n newest_id = newest_id or oldest_id\\n\\n all_tweets = []\\n i = 0\\n while i < count:\\n i += 1\\n # use search api to request 100 tweets. Twitter returns the most recent (max_id) first\\n if oldest_id <= newest_id:\\n tweets = get_tweets(query=query, max_id=oldest_id - 1, count=TWEETS_PER_SEARCH, twitter=twitter)\\n else:\\n tweets = get_tweets(query=query, max_id=oldest_id - 1, since_id=newest_id, count=TWEETS_PER_SEARCH, twitter=twitter)\\n rate_limit_remaining = twitter.get_lastfunction_header('x-rate-limit-remaining')\\n rate_limit_reset = twitter.get_lastfunction_header('x-rate-limit-reset')\\n\\n if not len(tweets):\\n # not rate limitted, just no tweets returned by query\\n oldest_id = oldest_id + ((newest_id or oldest_id) - oldest_id + 1) * 10000\\n break\\n elif isinstance(tweets, dict):\\n # rate limit hit, or other twython response error\\n print(tweets)\\n break\\n\\n all_tweets.extend(tweets)\\n\\n # determine new oldest id\\n tweet_ids = {t['id'] for t in tweets}\\n if oldest_id:\\n tweet_ids.add(oldest_id)\\n oldest_id, newest_id = min(tweet_ids), max(tweet_ids)\\n if rate_limit_remaining == 1:\\n time.sleep(rate_limit_reset - time.time())\\n\\n save_tweets(all_tweets, query=query)\\n\\n # set id to start from for next time\\n _set_oldest_id(oldest_id, newest_id, query=query)\\n\\n if len(all_tweets) == 0:\\n os.remove(make_oldest_id_path(query))\\n\\n return len(all_tweets), twitter.get_lastfunction_header('x-rate-limit-remaining')\",\n \"def twitter(self):\\n\\n q = \\\" OR \\\".join(self.search_terms) + \\\" -filter:retweets\\\"\\n results = self.__api.search(q=q, lang='en', count=100)\\n\\n tweets = []\\n\\n for res in results:\\n\\n publishedAt = datetime.strptime(res._json['created_at'], '%a %b %d %H:%M:%S +0000 %Y').strftime(\\\"%Y-%m-%d\\\")\\n\\n if (res._json['in_reply_to_screen_name'] == None and publishedAt == datetime.now().strftime(\\\"%Y-%m-%d\\\")):\\n tweets.append([res._json['id'],\\n res._json['text'],\\n res._json['user']['screen_name'],\\n publishedAt,\\n res._json['user']['followers_count']])\\n\\n self.list = pd.DataFrame(tweets, columns=['id', 'title', 'user', 'publishedAt', 'followers_count']).nlargest(10,\\n 'followers_count')\\n\\n return\",\n \"def get_live_tweets_from_twitter_stream(auth, terms, num_tweets):\\n listener = TwitterListener()\\n listener._max_tweets = num_tweets\\n twitter_stream = Stream(auth, listener)\\n twitter_stream.filter(track=terms, languages=['en'])\\n listener.store_live_tweets()\",\n \"def get_tweets():\\n\\n return Tweet.query.all()\",\n \"def get_tweets(which, hours):\\n objects = tweepy.Cursor(\\n twitter.list_timeline,list_id=which,\\n include_rts=False,count=100\\n ).items()\\n time_objects = []\\n cutoff = (\\n datetime.utcnow() - timedelta(hours=hours)\\n ).strftime('%b %d %H:%M:%S')\\n for tweet in objects:\\n data = tweet._json # isolate metadata\\n raw_time = datetime.strptime(\\n data['created_at'],\\n '%a %b %d %H:%M:%S +0000 %Y'\\n )\\n time = raw_time.strftime('%b %d %H:%M:%S') # reformat to match cutoff for boolean\\n if time > cutoff:\\n time_objects.append(tweet)\\n return time_objects\",\n \"def TweetColecting(list_of_kw, startdate, enddate, exclude, outfile):\\n\\tlist_of_kw = [f'\\\"{item}\\\" OR ' for item in list_of_kw]\\n\\tkeys_to_scrap = [''.join(list_of_kw).strip(\\\" OR \\\")]\\n\\t#print(keys_to_scrap)\\n\\n\\tdaterange = (pd.date_range(start=startdate, end=enddate, freq='24h'))\\n\\n\\n\\n\\tprint(\\\"\\\\nCollecting tweets by key : \\\", key)\\n\\n\\tfor single_date in daterange:\\n\\n\\t\\tday_after = single_date + relativedelta(days=1)\\n\\n\\t\\toutputFilePath = \\\"./\\\" + outfile + \\\"/\\\"\\n\\t\\toutputFileName = str(single_date.strftime(\\\"%Y-%m-%d\\\")) + \\\".csv\\\"\\n\\n\\t\\tif not os.path.exists(outfile):\\n\\t\\t\\tos.makedirs(outfile)\\n\\n\\t\\tprint(\\\"\\\\nCollecting tweets between\\\", single_date.strftime(\\\"%Y-%m-%d\\\"), \\\" to \\\", day_after.strftime(\\\"%Y-%m-%d\\\"), \\\"for\\\", outputFilePath + outputFileName)\\n\\n\\t\\ttweetCriteria = (got.manager.TweetCriteria()\\n\\t\\t\\t\\t\\t\\t .setQuerySearch(key)\\n\\t\\t\\t\\t\\t\\t .setSince(single_date.strftime(\\\"%Y-%m-%d\\\"))\\n\\t\\t\\t\\t\\t\\t .setUntil(day_after.strftime(\\\"%Y-%m-%d\\\")).setLang('en')\\n\\t\\t\\t\\t\\t\\t .setEmoji('named')\\n\\t\\t\\t\\t\\t\\t .setExcludeWords(exclude))\\n\\n\\t\\toutputFile = codecs.open(outputFilePath + outputFileName, \\\"a\\\", \\\"utf-8\\\")\\n\\n\\t\\tprint('Searching...\\\\n')\\n\\n\\t\\ttweet = got.manager.TweetManager.getTweets(tweetCriteria, receiveBuffer, outputFile)\\n\\t\\ttime.sleep(2)\",\n \"def get_all(self, start_at, limit, order=None):\",\n \"def fetch_daterange(self, start_date, end_date=None, table='fashion'):\\n\\n if end_date is None:\\n end_date = datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')\\n\\n end_date_obj = datetime.strptime(end_date, '%Y-%m-%d %H:%M:%S')\\n end_day = '{:04d}-{:02d}-{:02d}'.format(end_date_obj.year, \\n end_date_obj.month, \\n end_date_obj.day)\\n\\n start_date_obj = datetime.strptime(start_date, '%Y-%m-%d %H:%M:%S')\\n curr_day = '{:04d}-{:02d}-{:02d}'.format(start_date_obj.year, \\n start_date_obj.month, \\n start_date_obj.day)\\n \\n record_lookup_stmt = \\\"SELECT * FROM {} WHERE date=%s AND t>%s and t<%s\\\".format(table)\\n \\n record_list = []\\n while curr_day <= end_day: \\n record_list += self.session.execute(record_lookup_stmt, [curr_day, \\n start_date,\\n end_date])\\n start_date_obj += timedelta(days=1)\\n curr_day = '{:04d}-{:02d}-{:02d}'.format(start_date_obj.year, \\n start_date_obj.month, \\n start_date_obj.day) \\n\\n return record_list\",\n \"def query_tweets_once(query, limit=None, num_tweets=0):\\n logging.info(\\\"Querying {}\\\".format(query))\\n query = query.replace(' ', '%20').replace(\\\"#\\\", \\\"%23\\\").replace(\\\":\\\", \\\"%3A\\\")\\n pos = None\\n tweets = []\\n try:\\n while True:\\n new_tweets, pos = query_single_page(\\n INIT_URL.format(q=query) if pos is None\\n else RELOAD_URL.format(q=query, pos=pos),\\n pos is None\\n )\\n if len(new_tweets) == 0:\\n logging.info(\\\"Got {} tweets for {}.\\\".format(\\n len(tweets), query))\\n return tweets\\n\\n logging.info(\\\"Got {} tweets ({} new).\\\".format(\\n len(tweets) + num_tweets, len(new_tweets)))\\n\\n tweets += new_tweets\\n\\n if limit is not None and len(tweets) + num_tweets >= limit:\\n return tweets\\n except KeyboardInterrupt:\\n logging.info(\\\"Program interrupted by user. Returning tweets gathered \\\"\\n \\\"so far...\\\")\\n except BaseException:\\n logging.exception(\\\"An unknown error occurred! Returning tweets \\\"\\n \\\"gathered so far.\\\")\\n\\n return tweets\",\n \"def getTweets(user,maxTweets=3000,count=0,tweetId=0,cacheKey=False,credentials=False):\\n api = ratedTwitter(credentials=credentials)\\n limit = api.get_user_timeline_limited()\\n if limit:\\n print '*** TWITTER RATE-LIMITED: statuses.user_timeline:'+user+':'+str(count)+' ***'\\n raise getTweets.retry(countdown = limit)\\n else:\\n args = {'screen_name':user,'exclude_replies':False,'include_rts':True,'trim_user':False,'count':200}\\n if tweetId:\\n args['max_id'] = tweetId\\n \\n okay, result = api.get_user_timeline(**args)\\n \\n if okay:\\n print '*** TWITTER USER_TIMELINE: '+user+':'+str(tweetId)+' ***'\\n if result:\\n newCount = count + len(result)\\n if maxTweets:\\n if newCount > maxTweets: # No need for the task to call itself again.\\n pushTweets.delay(result,user,cacheKey=cacheKey) # Give pushTweets the cache-key to end the job.\\n return\\n else:\\n pushTweets.delay(result,user)\\n\\n newTweetId = min([t['id'] for t in result]) - 1 \\n # Not done yet, the task calls itself with an updated count and tweetId.\\n getTweets.delay(user,maxTweets=maxTweets,count=newCount,tweetId=newTweetId,cacheKey=cacheKey,credentials=credentials)\\n else:\\n pushTweets.delay([],user,cacheKey=cacheKey) # Nothing more found, so tell pushTweets the job is done.\\n else:\\n if result == '404':\\n setUserDefunct(user)\\n cache.set('scrape_tweets','done')\\n if result == 'limited':\\n raise getTweets.retry(countdown = api.get_user_timeline_limited())\",\n \"def get_tweets_from_search(api, search_string, parameters=\\\" -filter:retweets\\\", since=\\\"2021-08-09\\\", lang=\\\"en\\\", max_tweets=1000):\\n\\n tweet_list = []\\n count = 0\\n search = search_string\\n params = parameters\\n\\n for tweet in tweepy.Cursor(api.search, q=search + params,\\n count=100,\\n tweet_mode=\\\"extended\\\",\\n lang=lang,\\n since=since,\\n # until=\\\"2015-02-01\\\",\\n ).items():\\n tweet_list.append(tweet._json[\\\"full_text\\\"])\\n count += 1\\n if count == max_tweets:\\n break\\n print(count)\\n return pd.DataFrame({\\\"text\\\": tweet_list})\",\n \"def get_tweets_upload_to_bq(users, min_date, max_date, result_limit, key, secret_key, project_id, table_id, **context):\\n\\n if context.get(\\\"yesterday_ds\\\"):\\n df = get_users_tweets(users, context['yesterday_ds'], context['yesterday_ds'], result_limit, key, secret_key)\\n else: \\n df = get_users_tweets(users, min_date, max_date, result_limit, key, secret_key)\\n upload_df_to_bq(df, project_id, table_id)\\n\\n return 'scraped tweets and uploaded to bq'\",\n \"def get_tweets(api, query):\\n \\n results = []\\n for tweet in tweepy.Cursor(api.search, q=query).items(1000):\\n results.append(tweet)\\n \\n id_list = [tweet.id for tweet in results]\\n #unpack into dataframe\\n data = pd.DataFrame(id_list,columns=['id'])\\n \\n data[\\\"text\\\"]= [tweet.text.encode('utf-8') for tweet in results]\\n data[\\\"datetime\\\"]=[tweet.created_at for tweet in results]\\n data[\\\"Location\\\"]=[tweet.place for tweet in results]\\n \\n return data\",\n \"async def get_tweets(self, ctx, username: str, count: int):\\n cnt = count\\n if count > 25:\\n cnt = 25\\n\\n if username is not None:\\n if cnt < 1:\\n await self.bot.say(\\\"I can't do that, silly! Please specify a \\\\\\n number greater than or equal to 1\\\")\\n return\\n msg_list = []\\n api = self.authenticate()\\n try:\\n for status in\\\\\\n tw.Cursor(api.user_timeline, id=username).items(cnt):\\n if not status.text.startswith(\\\"@\\\"):\\n msg_list.append(status)\\n except tw.TweepError as e:\\n await self.bot.say(\\\"Whoops! Something went wrong here. \\\\\\n The error code is \\\" + str(e))\\n return\\n if len(msg_list) > 0:\\n await self.tweet_menu(ctx, msg_list, page=0, timeout=30)\\n else:\\n await self.bot.say(\\\"No tweets available to display!\\\")\\n else:\\n await self.bot.say(\\\"No username specified!\\\")\\n return\",\n \"def get_tweets_from_username(api, screen_name):\\n\\n # initialize a list to hold all the Tweets\\n alltweets = []\\n output = []\\n\\n # make initial request for most recent tweets\\n # (200 is the maximum allowed count)\\n new_tweets = api.user_timeline(screen_name=screen_name, count=200, tweet_mode=\\\"extended\\\")\\n\\n # save most recent tweets\\n alltweets.extend(new_tweets)\\n\\n # save the id of the oldest tweet less one to avoid duplication\\n oldest = alltweets[-1].id - 1\\n\\n # keep grabbing tweets until there are no tweets left\\n while len(new_tweets) > 0:\\n print(\\\"Getting tweets before %s\\\" % (oldest))\\n\\n # all subsequent requests use the max_id param to prevent\\n # duplicates\\n new_tweets = api.user_timeline(screen_name=screen_name, count=200, max_id=oldest, tweet_mode=\\\"extended\\\")\\n\\n # save most recent tweets\\n alltweets.extend(new_tweets)\\n\\n # update the id of the oldest tweet less one\\n oldest = alltweets[-1].id - 1\\n print(\\\"... %s tweets downloaded so far\\\" % (len(alltweets)))\\n\\n # transform the tweepy tweets into a 2D array that will\\n for tweet in alltweets:\\n output.append([tweet.id_str,\\n tweet.created_at,\\n tweet.full_text,\\n tweet.in_reply_to_screen_name,\\n tweet.user.name,\\n tweet.user.location,\\n tweet.user.followers_count,\\n tweet.user.friends_count,\\n tweet.geo,\\n tweet.coordinates,\\n tweet.retweet_count,\\n tweet.favorite_count,\\n tweet.lang,\\n tweet.retweeted])\\n\\n # Convert to dataframe\\n df = pd.DataFrame.from_records(output, columns=[\\\"id_str\\\",\\n \\\"created_at\\\",\\n \\\"full_text\\\",\\n \\\"in_reply_to_screen_name\\\",\\n \\\"user_name\\\",\\n \\\"user_location\\\",\\n \\\"user_followers_count\\\",\\n \\\"user_friends_count\\\",\\n \\\"geo\\\",\\n \\\"coordinates\\\",\\n \\\"retweet_count\\\",\\n \\\"favorite_count\\\",\\n \\\"lang\\\",\\n \\\"retweeted\\\"])\\n return df\",\n \"def get_tweets():\\n\\n\\tuser ='kaiserkumars'\\n\\t# api = twitter.Api(consumer_key='iJoZZuV7etVrJfE4K9ir8sIqa',\\n\\t# consumer_secret='uyJyWoP05z2MUKnggW7vHnIG2sckmM1aHRMgGveZLyrz8401Xs',\\n\\t# access_token_key='622588040-TYDgG1UlGUvA1hW8PA7mOG5CiMw0WiuPZlkoP8cc',\\n\\t# access_token_secret='laAmFjeLhWzOK7Y524VevdMdeLeNpnmCUmjee1AQU7osj')\\n\\tapi = twitter.Api(consumer_key=get_secret('consumer_key'),\\n\\t consumer_secret=get_secret('consumer_secret'),\\n\\t access_token_key=get_secret('access_token_key'),\\n\\t access_token_secret=get_secret('access_token_secret'))\\n\\n\\tstatuses = api.GetUserTimeline(user_id=622588040,count=0)\\n\\t# print(statuses)\\n\\t# duplicate='UNIQUE constraint failed: mtwitter_weatherdata.location, core_weatherdata.metric, core_weatherdata.date'\\n\\tbulk_insert=[]\\n\\t# print(dir(TwitterData))\\n\\tfor s in statuses:\\n\\t\\t# print(s)\\n\\t\\tdt = parse(s.created_at)\\n\\t\\t# print(dt)\\n\\t\\tdata = TwitterData(org_name=s.user.name,profile_url=s.user.profile_image_url,tweet_id =s.id,screen_name=s.user.screen_name, tweet = s.text, date= dt, favCount =0)\\n\\t\\tbulk_insert.append(data)\\n\\ttry:\\n\\t\\tTwitterData.objects.bulk_create(bulk_insert)\\n\\t\\tprint(\\\"Success.\\\")\\n\\texcept Exception as e:\\n\\t\\t# if(str(e)==duplicate):\\n\\t\\t# \\tprint('Duplicate Data')\\n\\t\\t# else:\\n\\t\\tprint(str(e))\\n\\n\\treturn statuses\",\n \"def collect_tweets(redis_client, twitter_client, search_term):\\n search = Search(redis_client, twitter_client, search_term)\\n search.get_term_state()\\n search.parse_term_state()\\n search.set_query_string()\\n search.set_execution_time()\\n search.execute_query()\\n search.incr_query_counters()\\n search.set_newest_id()\\n search.set_oldest_id()\\n search.set_scenario()\\n search.set_term_state()\\n search.store_results()\\n search.set_score()\\n search.log_state()\",\n \"def fetch_tweets(self, screen_name, count):\\n return {}\",\n \"def process_tweet(tweet):\\n global start_date\\n global end_date\\n global geo_enabled_tweets\\n global retweets\\n\\n # Check for filters before processing any further\\n if args.filter and tweet.source:\\n if not args.filter.lower() in tweet.source.lower():\\n return\\n\\n tw_date = tweet.created_at\\n\\n # Updating most recent tweet\\n end_date = end_date or tw_date\\n start_date = tw_date\\n\\n # Handling retweets\\n try:\\n # We use id to get unique accounts (screen_name can be changed)\\n rt_id_user = tweet.retweeted_status.user.id_str\\n retweeted_users[rt_id_user] += 1\\n\\n if tweet.retweeted_status.user.screen_name not in id_screen_names:\\n id_screen_names[rt_id_user] = \\\"@%s\\\" % tweet.retweeted_status.user.screen_name\\n\\n retweets += 1\\n except:\\n pass\\n\\n # Adding timezone from profile offset to set to local hours\\n if tweet.user.utc_offset and not args.no_timezone:\\n tw_date = (tweet.created_at + datetime.timedelta(seconds=tweet.user.utc_offset))\\n\\n if args.utc_offset:\\n tw_date = (tweet.created_at + datetime.timedelta(seconds=args.utc_offset))\\n\\n # Updating our activity datasets (distribution maps)\\n activity_hourly[\\\"%s:00\\\" % str(tw_date.hour).zfill(2)] += 1\\n activity_weekly[str(tw_date.weekday())] += 1\\n\\n # Updating langs\\n detected_langs[tweet.lang] += 1\\n\\n # Updating sources\\n detected_sources[tweet.source] += 1\\n\\n # Detecting geolocation\\n if tweet.place:\\n geo_enabled_tweets += 1\\n tweet.place.name = tweet.place.name\\n detected_places[tweet.place.name] += 1\\n\\n # Updating hashtags list\\n if tweet.entities['hashtags']:\\n for ht in tweet.entities['hashtags']:\\n ht['text'] = \\\"#%s\\\" % ht['text']\\n detected_hashtags[ht['text']] += 1\\n\\n # Updating domains list\\n if tweet.entities['urls']:\\n for url in tweet.entities['urls']:\\n domain = urlparse(url['expanded_url']).netloc\\n if domain != \\\"twitter.com\\\": # removing twitter.com from domains (not very relevant)\\n detected_domains[domain] += 1\\n\\n # Updating mentioned users list\\n if tweet.entities['user_mentions']:\\n for ht in tweet.entities['user_mentions']:\\n mentioned_users[ht['id_str']] += 1\\n if not ht['screen_name'] in id_screen_names:\\n id_screen_names[ht['id_str']] = \\\"@%s\\\" % ht['screen_name']\",\n \"def get_tweets():\\n if not Tweet.objects.all():\\n # If the db is empty, don't get max_id.\\n tweets = api.search(\\n q='#python',\\n count=100\\n )\\n else:\\n # If the db is not empty, get max_id.\\n subtask(clean_tweetdb)\\n max_id = min([tweet.tweet_id for tweet in Tweet.objects.all()])\\n tweets = api.search(\\n q='#python',\\n max_id=max_id,\\n count=100\\n )\\n\\n # Store the tweet data in lists.\\n tweets_id = [tweet.id for tweet in tweets]\\n tweets_date = [tweet.created_at for tweet in tweets]\\n tweets_source = [tweet.source for tweet in tweets]\\n tweets_favorite_cnt = [tweet.favorite_count for tweet in tweets]\\n tweets_retweet_cnt = [tweet.retweet_count for tweet in tweets]\\n tweets_text = [tweet.text for tweet in tweets]\\n\\n # Iterate over these lists and add data to db.\\n for i, j, k, l, m, n in zip(\\n tweets_id,\\n tweets_date,\\n tweets_source,\\n tweets_favorite_cnt,\\n tweets_retweet_cnt,\\n tweets_text,\\n ):\\n try:\\n # Check that they are valid.\\n Tweet.objects.create(\\n tweet_id=i,\\n tweet_date=j,\\n tweet_source=k,\\n tweet_favorite_cnt=l,\\n tweet_retweet_cnt=m,\\n tweet_text=n,\\n )\\n except IntegrityError:\\n pass\",\n \"def get_tweets(api, username, fh, limit):\\n if args.json is False:\\n for status in tqdm(tweepy.Cursor(api.user_timeline, screen_name=username).items(limit), unit=\\\"tw\\\", total=limit):\\n process_tweet(status)\\n if args.save:\\n fh.write(str(json.dumps(status._json))+\\\",\\\")\\n else:\\n for status in (tweepy.Cursor(api.user_timeline, screen_name=username).items(limit)):\\n process_tweet(status)\\n if args.save:\\n fh.write(str(json.dumps(status._json))+\\\",\\\")\",\n \"def get_tweets(query, pages=25):\\n\\n logger = Logger()\\n after_part = 'include_available_features=1&include_entities=1&include_new_items_bar=true'\\n if query.startswith('#'):\\n query = quote(query)\\n url = 'https://twitter.com/i/search/timeline?f=tweets&vertical=default&q={}&src=tyah&reset_error_state=false&'.format(query)\\n else:\\n url = 'https://twitter.com/i/profiles/show/{}/timeline/tweets?'.format(query)\\n url += after_part\\n \\n headers = {\\n 'Accept': 'application/json, text/javascript, */*; q=0.01',\\n 'Referer': 'https://twitter.com/{}'.format(query),\\n 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.1.2 Safari/603.3.8',\\n 'X-Twitter-Active-User': 'yes',\\n 'X-Requested-With': 'XMLHttpRequest',\\n 'Accept-Language': 'en-US'\\n }\\n\\n def gen_tweets(pages):\\n logger.add(\\\"MSG: Sending request to url '{}'...\\\".format(url))\\n r = session.get(url, headers=headers)\\n\\n logger.add(\\\"MSG: Parsing result...\\\".format(url))\\n while pages > 0:\\n try:\\n html = BeautifulSoup(r.json()['items_html'], parser='html', features=\\\"lxml\\\")\\n except KeyError:\\n raise ValueError(\\n 'Oops! Either \\\"{}\\\" does not exist or is private.'.format(query))\\n\\n comma = \\\",\\\"\\n dot = \\\".\\\"\\n tweets = []\\n for tweet in html.select('.stream-item'):\\n # 10~11 html elements have `.stream-item` class and also their `data-item-type` is `tweet`\\n # but their content doesn't look like a tweet's content\\n try:\\n text = tweet.select('.tweet-text')[0].get_text()\\n except IndexError: # issue #50\\n continue\\n\\n tweet_id = tweet['data-item-id']\\n\\n time = datetime.fromtimestamp(int(tweet.select('._timestamp')[0]['data-time-ms']) / 1000.0)\\n\\n interactions = [\\n x.get_text()\\n for x in tweet.select('.ProfileTweet-actionCount')\\n ]\\n\\n replies = int(\\n interactions[0].split(' ')[0].replace(comma, '').replace(dot, '')\\n or interactions[3]\\n )\\n\\n retweets = int(\\n interactions[1].split(' ')[0].replace(comma, '').replace(dot, '')\\n or interactions[4]\\n or interactions[5]\\n )\\n\\n likes = int(\\n interactions[2].split(' ')[0].replace(comma, '').replace(dot, '')\\n or interactions[6]\\n or interactions[7]\\n )\\n\\n hashtags = [\\n hashtag_node.get_text()\\n for hashtag_node in tweet.select('.twitter-hashtag')\\n ]\\n urls = [\\n url_node['data-expanded-url']\\n for url_node in tweet.select('a.twitter-timeline-link:not(.u-hidden)')\\n ]\\n photos = [\\n photo_node['data-image-url']\\n for photo_node in tweet.select('.AdaptiveMedia-photoContainer')\\n ]\\n\\n is_retweet = False\\n if tweet.select('.js-stream-tweet')[0].has_attr('data-retweet-id'):\\n is_retweet = True\\n\\n is_pinned = False\\n if tweet.select(\\\".pinned\\\"):\\n is_pinned = True\\n\\n videos = []\\n video_nodes = tweet.select(\\\".PlayableMedia-player\\\")\\n for node in video_nodes:\\n styles = node['style'].split()\\n for style in styles:\\n if style.startswith('background'):\\n tmp = style.split('/')[-1]\\n video_id = tmp[:tmp.index('.jpg')]\\n videos.append({'id': video_id})\\n\\n tweets.append({\\n 'tweetId': tweet_id,\\n 'isRetweet': is_retweet,\\n 'time': time,\\n 'text': text,\\n 'replies': replies,\\n 'retweets': retweets,\\n 'likes': likes,\\n 'isPinned': is_pinned,\\n 'entries': {\\n 'hashtags': hashtags, 'urls': urls,\\n 'photos': photos, 'videos': videos\\n }\\n })\\n\\n\\n last_tweet = html.select('.stream-item')[-1]['data-item-id']\\n\\n for tweet in tweets:\\n if tweet:\\n tweet['text'] = re.sub(r'\\\\Shttp', ' http', tweet['text'], 1)\\n tweet['text'] = re.sub(r'\\\\Spic\\\\.twitter', ' pic.twitter', tweet['text'], 1)\\n yield tweet\\n\\n r = session.get(url, params={'max_position': last_tweet}, headers=headers)\\n pages += -1\\n yield from gen_tweets(pages)\",\n \"def binary_search_tweets_by_date(tweets, targetDate, start, end):\\n # no exact match in tweets\\n if (start >= end):\\n # TODO will this cover edge cases?? (end and beginning of list?)\\n print(\\\"closest? %d\\\" % (start - 1))\\n return start - 1\\n\\n middle = int((start + end) / 2)\\n value = tweets[middle].created_at\\n\\n if value > targetDate:\\n return binary_search_tweets_by_date(tweets, targetDate, middle+1, end)\\n if value < targetDate:\\n return binary_search_tweets_by_date(tweets, targetDate, start, middle-1)\\n # found exact match\\n return middle\",\n \"def execute(self, *args, **kwargs):\\n try:\\n self.timeline_tweets = self.api.user_timeline(\\n kwargs['screen_name'])\\n except TweepError as user_timeline_error:\\n print(user_timeline_error)\\n self.user_timeline_tweets_status = False\",\n \"def trendingTweets():\\n api = twitter.Api()\\n trending_topics = api.GetTrendsWoeid(PHILA_WOEID)\\n for topic in trending_topics:\\n topicSearchTerm = topic.name\\n trending_tweets = api.GetSearch(topicSearchTerm)\\n for tweet in trending_tweets:\\n util.safe_print(tweet.GetText())\\n # pass\",\n \"def collect(self, start_date=None, end_date=None):\\n if start_date is None:\\n start_date = self.default_start\\n if end_date is None:\\n end_date = self.default_end\\n\\n cur = self.conn.cursor()\\n\\n # Maximum return is 1000 entries\\n num_days = 1000 // len(self.stations)\\n # Maximum date-range is 1 year\\n if num_days > 365:\\n num_days = 365\\n\\n for interval in netzero.util.time_intervals(\\n start_date, end_date, days=num_days\\n ):\\n netzero.util.print_status(\\n \\\"Weather\\\",\\n \\\"Collecting: {} to {}\\\".format(\\n interval[0].strftime(\\\"%Y-%m-%d\\\"), interval[1].strftime(\\\"%Y-%m-%d\\\")\\n ),\\n )\\n\\n # TODO -- REMOVE ASSUMPTION THAT LEN(DATA) < LIMIT\\n raw_data = self.query_api(interval[0], interval[1])\\n\\n if raw_data is None:\\n print(\\\"ERROR QUERYING API\\\") # TODO exception here?\\n continue\\n\\n for entry in raw_data.get(\\\"results\\\", []):\\n # Insert the weather data to the table, to be averaged later\\n date = datetime.datetime.strptime(\\n entry[\\\"date\\\"], \\\"%Y-%m-%dT%H:%M:%S\\\"\\n ).date()\\n value = entry[\\\"value\\\"]\\n station = entry[\\\"station\\\"]\\n\\n cur.execute(\\n \\\"INSERT OR IGNORE INTO weather VALUES (?, ?, ?)\\\", (date, value, station)\\n )\\n\\n self.conn.commit()\\n\\n cur.close()\\n\\n netzero.util.print_status(\\\"Weather\\\", \\\"Complete\\\", newline=True)\",\n \"def get_timeline_events(self, req, start, stop, filters):\",\n \"def get_tweet(username, n):\\n return twitterAPI.home_timeline(count=n)[-1:][0] # return specified tweet\",\n \"def get_tweets(self):\\n\\t\\ttweets = ''\\n\\t\\tfor each in self.tweets_posted:\\n\\t\\t\\ttweets += each.timeline_format() + '\\\\n'\\n\\t\\ttweets = tweets.strip('\\\\n')\\n\\t\\treturn tweets\",\n \"def getTweetsPerUser(self, fromDate, toDate, number):\\n return self.session.query(func.count(User.id), User.screen_name).\\\\\\n join(Tweet).group_by(User.id).\\\\\\n order_by(desc(func.count(User.id))).\\\\\\n filter(Tweet.created_at > fromDate).\\\\\\n filter(Tweet.created_at < toDate)[0: number]\",\n \"def userTweets(username):\\n api = twitter.Api()\\n user_tweets = api.GetUserTimeline(username)\\n for tweet in user_tweets:\\n util.safe_print(tweet.GetText())\",\n \"def getNewsFeed(self, userId: int):\\n tweets = heapq.merge(*(self.tweets[u] for u in self.followees[userId] | {userId}))\\n return [t for _, t in itertools.islice(tweets, 10)]\",\n \"def get_tweets(self, output_path, tweets_ids):\\n\\n\\t\\tloading = 0\\n\\n\\t\\tapp = TwitterApp.get_twitter_app_instance(self)\\n\\n\\t\\ttweets_content = []\\n\\n\\t\\tnew_tweets_ids = []\\n\\n\\t\\tqty_tweets = len(tweets_ids)\\n\\n\\t\\tlast_index = 0\\n\\n\\t\\twhile True:\\n\\t\\t\\t\\n\\t\\t\\ttry:\\n\\n\\t\\t\\t\\tresponse = app.GetStatuses(tweets_ids[last_index:last_index+100], map=True)\\n\\t\\t\\t\\t\\n\\t\\t\\texcept Exception as e:\\n\\n\\t\\t\\t\\t# save the available posts to this time\\n\\t\\t\\t\\tdataset = pd.DataFrame({'tweet_id':new_tweets_ids, 'post_content':tweets_content})\\n\\t\\t\\t\\twrite_tweets(output_path, dataset)\\n\\n\\t\\t\\t\\tlogging.info(''.join(['Error on request ', str(loading)]))\\n\\n\\t\\t\\t\\tprint(\\\"ERROR:\\\", e)\\n\\n\\t\\t\\t\\t'''\\n\\t\\t\\t\\tUsually, the rate limit allowed by Twitter API is exceeded (in this case GET statuses/lookup is 900 for user auth and 300 for the app auth for every 15 minutes), one way to deal with it is sleeping the code for approximately 15 minutes to continue after.\\n\\t\\t\\t\\t'''\\n\\t\\t\\t\\ttime.sleep(950)\\n\\n\\t\\t\\t\\ttry:\\n\\n\\t\\t\\t\\t\\tresponse = app.GetStatuses(tweets_ids[last_index:last_index+100], map=True)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\texcept Exception as e:\\n\\n\\t\\t\\t\\t\\tprint(e)\\n\\t\\t\\t\\t\\texit(1)\\n\\n\\n\\t\\t\\tfor id_value, text in response.items():\\t\\t\\t\\n\\n\\t\\t\\t\\t# This means that the post is not available now.\\n\\t\\t\\t\\tif (text == None):\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\telse:\\n\\n\\t\\t\\t\\t\\tnew_tweets_ids.append(id_value)\\n\\t\\t\\t\\t\\ttweets_content.append(text.text)\\n\\n\\t\\t\\t# Each request gets 100 posts\\n\\t\\t\\tlast_index = last_index + 100\\n\\n\\t\\t\\t# There is no more IDs\\n\\t\\t\\tif (last_index > qty_tweets):\\n\\t\\t\\t\\tbreak\\t\\n\\t\\t\\n\\t\\t# save all tweets\\n\\t\\tdataset = pd.DataFrame({'tweet_id':new_tweets_ids, 'post_content':tweets_content})\\n\\t\\twrite_tweets(output_path, dataset)\",\n \"def api_get_tweets(request, topic):\\n bottom_id = request.query_params.get('bottomId', None)\\n\\n if bottom_id is None:\\n tweets = get_first_tweets(topic)\\n if tweets:\\n for tweet in tweets:\\n tweet['data']['id'] = str(tweet['data']['id'])\\n return Response({\\\"tweets\\\": tweets}, status=status.HTTP_200_OK)\\n\\n return Response({\\\"error\\\": \\\"topic not supported\\\"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)\\n\\n else:\\n bottom_id = int(bottom_id)\\n tweets = get_next_tweets(topic, bottom_id)\\n if tweets:\\n for tweet in tweets:\\n tweet['data']['id'] = str(tweet['data']['id'])\\n return Response({\\\"tweets\\\": tweets}, status=status.HTTP_200_OK)\\n\\n return Response({\\\"error\\\": \\\"no tweets anymore\\\"}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)\",\n \"def get_financial_tweets(symbol, result_type, n_items, date_range=\\\"all\\\"):\\n today = datetime.utcnow()\\n # Query for twitter API to be symbol prepended with a '$' sign to get financial tweets\\n query = f\\\"${symbol} -filter:retweets\\\"\\n if date_range == \\\"all\\\":\\n tweets = tweepy.Cursor(api.search, q=query, lang=\\\"en\\\", result_type=result_type, \\n tweet_mode=\\\"extended\\\").items(n_items)\\n else:\\n tweets = tweepy.Cursor(api.search, q=query, lang=\\\"en\\\", result_type=result_type, \\n since=today.strftime(\\\"%Y-%m-%d\\\"), tweet_mode=\\\"extended\\\").items(n_items)\\n\\n for tweet in tweets:\\n yield Tweet(id=tweet.id, date=tweet.created_at.strftime(\\\"%Y-%m-%d\\\"), \\n symbol=symbol, text=tweet.full_text, likes=tweet.favorite_count)\",\n \"def get_user_tweets(api, screen_name, output_path):\\n logger = logging.getLogger(__name__)\\n logger.info('Pulling tweets')\\n\\n # Create empty list for tweet objects\\n tweets = []\\n # Pulls users must recent 200 tweets\\n new_tweets = api.user_timeline(screen_name=screen_name, count=200)\\n tweets.extend(new_tweets)\\n oldest = tweets[-1].id - 1\\n\\n # Continues to pull tweets 200 at a time until limit is hit\\n while len(new_tweets) > 0:\\n new_tweets = api.user_timeline(screen_name=screen_name,\\n count=200, max_id=oldest)\\n tweets.extend(new_tweets)\\n oldest = tweets[-1].id - 1\\n\\n logger.info(\\\"...%s tweets downloaded and cleaned\\\" % (len(tweets)))\\n\\n # Write all text of tweets to a file\\n filename = screen_name + '.csv'\\n file = open(join(output_path, filename), 'w')\\n\\n # Iterates through all tweets and cleans them before outputting\\n for tweet in tweets:\\n clean_tweet = clean_string(tweet.text)\\n line = screen_name + ', ' + clean_tweet + '\\\\n'\\n file.write(line)\\n logger.info(\\\"Done pulling tweets for %s\\\" % screen_name)\\n file.close()\",\n \"def read_tweets(self)-> None:\\n self.no_of_tweets = len(self.list_of_files)\\n for i in range(0, self.no_of_tweets):\\n # for i in range(0,10): # running a small loop for testing purpose\\n try:\\n with open(self.list_of_files[i]) as json_file:\\n file = json.load(json_file)\\n tweet = {'id': file['id']}\\n try:\\n tweet['created_time'] = file['retweeted_status']['created_at']\\n tweet['text'] = file['retweeted_status']['full_text']\\n except:\\n tweet['created_time'] = file['created_at']\\n tweet['text'] = file['full_text']\\n self.tweets.append(tweet)\\n except:\\n print(\\\"Error for \\\",self.list_of_files[i])\\n if i%1000 == 0:\\n print(str(round(i/self.no_of_tweets,2)*100),\\\"% read\\\")\\n print(\\\"All Tweets read into memory\\\")\",\n \"def get_tweets():\\r\\n tweets = models.Tweet.query.all()\\r\\n output = []\\r\\n\\r\\n for tweet in tweets:\\r\\n tweet_data = {'id': tweet.id,\\r\\n 'content': tweet.text_content,\\r\\n 'username': tweet.username,\\r\\n 'timestamp': tweet.timestamp.isoformat(),\\r\\n 'likes_count': models.Like.query.filter(models.Like.post_id == tweet.id).count(),\\r\\n 'retweets_count': models.Retweet.query.filter(models.Retweet.post_id == tweet.id).count()}\\r\\n\\r\\n output.append(tweet_data)\\r\\n\\r\\n return {\\\"tweets\\\": output}\",\n \"def crawl_twitter(list_ids, api, wait_on_rate_limit=False):\\n\\n ldc = []\\n count = 0\\n try:\\n for curr_id in list_ids:\\n for post in tweepy.Cursor(api.user_timeline, id=curr_id, summary=False, tweet_mode=\\\"extended\\\",\\n wait_on_rate_limit=wait_on_rate_limit).items():\\n dc = OrderedDict()\\n curr_post = post._json\\n dc['tweet_from'] = curr_id\\n dc['created_at'] = curr_post['created_at']\\n dc['hashtags'] = [x['text']\\n for x in curr_post['entities']['hashtags']]\\n dc['urls'] = [x['expanded_url']\\n for x in curr_post['entities']['urls']]\\n dc['user_mentions_id'] = [x['id']\\n for x in curr_post['entities']['user_mentions']]\\n if 'media' in curr_post['entities']:\\n dc['media'] = [x['media_url_https']\\n for x in curr_post['entities']['media']]\\n dc['user_mentions_name'] = [x['screen_name']\\n for x in curr_post['entities']['user_mentions']]\\n dc['origin_device'] = BeautifulSoup(\\n curr_post['source'], 'html.parser').a.string\\n dc['favorite_count'] = curr_post['favorite_count']\\n dc['text'] = curr_post['full_text']\\n dc['id'] = curr_post['id']\\n dc['in_reply_to_screen_name'] = curr_post[\\n 'in_reply_to_screen_name']\\n dc['in_reply_to_user_id'] = curr_post['in_reply_to_user_id']\\n dc['in_reply_to_status_id'] = curr_post[\\n 'in_reply_to_status_id']\\n dc['retweet_count'] = curr_post['retweet_count']\\n # adding retweet information because it is important.\\n if ('retweeted_status' in curr_post):\\n dc['retweeted_status_text'] = curr_post[\\n 'retweeted_status']['full_text']\\n dc['retweeted_status_url'] = [x['expanded_url']\\n for x in curr_post['retweeted_status']['entities']['urls']]\\n dc['retweeted_status_id'] = curr_post[\\n 'retweeted_status']['id']\\n dc['retweeted_status_user_name'] = curr_post[\\n 'retweeted_status']['user']['name']\\n dc['retweeted_status_user_handle'] = curr_post[\\n 'retweeted_status']['user']['screen_name']\\n ldc.append(dc)\\n count += 1\\n except Exception as twe:\\n print(str(twe))\\n print(\\\"Total count : \\\" + str(count))\\n return (ldc)\",\n \"def get(self, search_words, language, result_type):\\n consumer_key = config.twitter_api_credentials[\\\"consumer_key\\\"]\\n consumer_secret = config.twitter_api_credentials[\\\"consumer_secret\\\"]\\n access_token = config.twitter_api_credentials[\\\"access_token\\\"]\\n access_token_secret = config.twitter_api_credentials[\\\"access_token_secret\\\"] \\n \\n auth = tweepy.OAuthHandler(consumer_key, consumer_secret); \\n auth.set_access_token(access_token, access_token_secret);\\n api = tweepy.API(auth, wait_on_rate_limit=True) ; \\n \\n #input_params = ns.payload\\n #search_words = input_params['search_words'] \\n #language = input_params['language'] # Language code (follows ISO 639-1 standards)\\n #until_date = input_params['until_date']\\n #result_type = input_params['result_type'] until=until_date\\n\\n try:\\n results = tweepy.Cursor( api.search, q=search_words, lang=language, result_type = result_type).items(10) \\n out = { tweet.user.screen_name: { \\\"followers_count\\\": tweet.user.followers_count, \\\\\\n \\\"location\\\": tweet.user.location ,\\\"favorite_count\\\":tweet.favorite_count,\\\"text\\\": tweet.text} for tweet in results }\\n sorted_keys = {k:v[\\\"followers_count\\\"] for (k,v) in out.items()}\\n sorted_keys = sorted(sorted_keys, key=sorted_keys.__getitem__, reverse=True)\\n out = {k:out[k] for k in sorted_keys}\\n return out\\n except tweepy.error.TweepError as e:\\n return(json.loads(e.response.text)['errors'][0]['message'], 401)\",\n \"def get_user_timeline(self, username,\\n count=settings.TWITTER_DEFAULT_LIMIT):\\n url = urljoin(self.base_url, \\\"/statuses/user_timeline.json\\\")\\n response = self.session.get(\\n url,\\n params={\\n \\\"screen_name\\\": username,\\n \\\"count\\\": count,\\n # \\\"include_entities\\\": True\\n },\\n auth=self.__auth,\\n )\\n data = response.json()\\n if response.ok:\\n data = [Tweet(tweet_data) for tweet_data in data]\\n else:\\n if 'error' in data:\\n raise TwitterException(data['error'], code=response.status_code)\\n elif 'errors' in data:\\n error = data['errors'][0]\\n raise TwitterException(error['message'], code=response.status_code)\\n return data\",\n \"def geo_collect_tweets(search_term,latitude,longitude,radius):\\n i = None\\n tweets = []\\n rep = 1\\n for n in range(2): #can only search 100 tweets at a time, so run search multiple times\\n \\tresults = api.GetSearch(term = search_term, \\n \\t\\tcount = 100, \\n \\t\\tresult_type = 'recent', \\n \\t\\tmax_id = i, #start a search from the most recent tweet id, working backwards\\n \\t\\tgeocode =(latitude, longitude, radius))\\n for tweet in results:\\n tweets.append(tweet.text)\\n i = tweet.id - 1 #want it to start at the tweet after the last tweet\\n rep += 1\\n return list(set(tweets)) #set gets rid of repititve tweets, but need to return a list\",\n \"def get_tweets(self):\\n chunker = Chunker.Chunker(500)\\n for batch in chunker(self.cids):\\n query = [\\n {'$match': {'lid': {'$in': batch}}},\\n {'$project': {'lid': 1}},\\n ]\\n if isinstance(self.city, str) and self.city in cities.SHORT_KEY:\\n query[0]['$match']['city'] = self.city\\n res = self.checkinDB.aggregate(query)['result']\\n self.tweets_id = sorted([c['_id'] for c in res])\",\n \"def queryTerm2Twitter(term): \\n statusList = api.GetSearch(term, count=100, result_type='recent')\\n timeStampOfStatus = [datetime.fromtimestamp(i.created_at_in_seconds) for i in statusList]\\n timeStampOfStatus.sort() \\n return timeStampOfStatus[0]\",\n \"def get(self):\\n url = \\\"http://twitter.com/statuses/public_timeline.json\\\"\\n task = taskqueue.Task(\\n url='/tasks/fetch',\\n params={'url': url}\\n )\\n task.add('fetch')\",\n \"def getRunsBetween(self, date_start, date_end = None, include=True):\\n if date_end is None:\\n date_end = datetime.now()\\n\\n if type(date_start) != datetime:\\n date_start = datetime(*date_start)\\n\\n if type(date_end) != datetime:\\n date_end = datetime(*date_end)\\n\\n formatstr = \\\"%Y-%m-%d %H:%M:%S\\\"\\n query = \\\"\\\"\\\"SELECT run FROM runs WHERE \\\"\\\"\\\"\\n if include:\\n query += \\\"stop > '%s' AND start < '%s'; \\\"\\\"\\\" % (date_start.strftime(formatstr), date_end.strftime(formatstr))\\n else:\\n query += \\\"start > '%s' AND stop < '%s'; \\\"\\\"\\\" % (date_start.strftime(formatstr), date_end.strftime(formatstr))\\n return [r[0] for r in self.query(query)]\",\n \"def getTweetsByUser(username, maxTweets=1000):\\n if 'api' not in globals():\\n startTwitterApi(getApiKeys(fileName=\\\"apiConf2.txt\\\"))\\n myTweets=[]\\n if words:\\n apiRes = tweepy.Cursor(api.user_timeline,screen_name=username, count=100, tweet_mode='extended', include_rts=not removeRetweets).items()\\n for tweet in apiRes:\\n if any(containsWord(tweet._json['full_text'],word) for word in words):\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n else:\\n if sortBy=='newest':\\n for tweet in tweepy.Cursor(api.user_timeline,screen_name=username, count=100, tweet_mode='extended', include_rts=not removeRetweets).items(maxTweets):\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n else:\\n for tweet in tweepy.Cursor(api.user_timeline,screen_name=username, count=100, tweet_mode='extended', include_rts=not removeRetweets).items():\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n\\n return getTopNTweets(myTweets, maxTweets)\",\n \"def searchByKeyword(self, keyword, until=\\\"\\\", since=\\\"\\\", count=None, result_type=\\\"recent\\\"):\\n if count is None:\\n tweets = tweepy.Cursor(self.api.search, q=keyword, until=until, since=since, result_type=result_type,\\n full_text=True, tweet_mode=\\\"extended\\\", lang=\\\"en\\\").items()\\n else:\\n tweets = tweepy.Cursor(self.api.search, q=keyword, until=until, since=since, result_type=result_type,\\n full_text=True, tweet_mode=\\\"extended\\\", lang=\\\"en\\\").items(count)\\n\\n for status in tweets:\\n createdDate = parser.parse(str(status._json[\\\"created_at\\\"]).strip())\\n createdDate = createdDate.replace(\\n tzinfo=pytz.utc) - createdDate.utcoffset()\\n status_refined = {\\n 'keyword': keyword,\\n '_id': status._json[\\\"id\\\"],\\n 'created_at': createdDate,\\n 'tweetText': status._json[\\\"full_text\\\"],\\n 'hashtags': status._json[\\\"entities\\\"][\\\"hashtags\\\"],\\n 'userLoc': status._json[\\\"user\\\"][\\\"location\\\"],\\n 'tweetGeo': status._json[\\\"geo\\\"],\\n 'tweetCoordinates': status._json[\\\"coordinates\\\"],\\n 'tweetPlace': status._json[\\\"place\\\"],\\n 'retweet': {},\\n }\\n if hasattr(status, \\\"retweeted_status\\\"):\\n status_refined['tweetText'] = status._json[\\\"retweeted_status\\\"][\\\"full_text\\\"]\\n status_refined['retweet'] = {\\n 'original_retweet_id': status._json[\\\"retweeted_status\\\"][\\\"id\\\"],\\n 'origUserLoc': status._json[\\\"retweeted_status\\\"][\\\"user\\\"][\\\"location\\\"],\\n 'origTweetLoc': status._json[\\\"retweeted_status\\\"][\\\"geo\\\"],\\n 'origTweetPlace': status._json[\\\"retweeted_status\\\"][\\\"place\\\"],\\n 'origTweetCoord': status._json[\\\"retweeted_status\\\"][\\\"coordinates\\\"],\\n 'origHashtags': status._json[\\\"retweeted_status\\\"][\\\"entities\\\"][\\\"hashtags\\\"],\\n 'retweet_count': status._json[\\\"retweet_count\\\"],\\n }\\n self.tweets.append(status_refined)\\n return self.tweets\",\n \"def crawl(self, query, start_date, end_date, *args, **kwargs):\\n pass\",\n \"def collect_tweets(search_id, search_term, number_of_tweets):\\n\\n tweets = []\\n for tweet in api_collector.collect(search_term, number_of_tweets):\\n tweets.append((tweet.id_str, tweet.created_at, tweet.full_text))\\n if len(tweets) == 0:\\n search = Search.objects.get(pk=search_id)\\n search.empty = True\\n search.save()\\n notify_searchers.delay(search_id)\\n else:\\n classify_tweets.delay(search_id, tweets)\",\n \"def get_tweets(search_terms, geocode):\\n\\turl = 'http://search.twitter.com/search.json'\\n\\tparams = {\\n\\t\\t'q': search_terms,\\n\\t\\t'geocode': str(geocode['lat']) + ',' + str(geocode['lng']) + ',200mi'\\n\\t}\\n\\turl_params = urllib.urlencode(params)\\n\\tresult = urlfetch.fetch(url=url + '?' + url_params,\\n\\t\\t\\t\\t\\t\\t\\tmethod=urlfetch.GET)\\n\\n\\tif result.status_code == 200:\\n\\t\\titems = json.loads(result.content)['results']\\n\\t\\t# return [r['text'] for r in items]\\n\\t\\treturn items\",\n \"def load_all_tweets(self, count):\\n\\n for influencer in tqdm(self.influencers.allInfluencers, desc='Gathering Tweets'):\\n self.get_tweets(influencer, count)\",\n \"def getNewsFeed(self, userId):\\r\\n tweets = []\\r\\n \\r\\n tweets += self.tweets_by_user[userId]\\r\\n for other in self.follows[userId]:\\r\\n tweets += self.tweets_by_user[other]\\r\\n \\r\\n last_10_tweets = sorted(tweets)[-10:]\\r\\n return [tweetId for _, tweetId in last_10_tweets][::-1]\",\n \"def get_tweets(hashtag):\\n api = twitter.Api(consumer_key=TWITTER_API_CONSUMER_KEY,\\n consumer_secret=TWITTER_API_CONSUMER_SECRET,\\n access_token_key=TWITTER_API_ACCESS_TOKEN_KEY,\\n access_token_secret=TWITTER_API_ACCESS_TOKEN_SECRET)\\n\\n query = (f\\\"q=%23{HASHTAG}%20-RT\\\"\\n f\\\"&result_type=recent&since=2019-01-01&count={NUM_TWEETS}\\\")\\n results = api.GetSearch(raw_query=query)\\n\\n return [\\n format_tweet(tweet.AsDict())\\n for tweet in results\\n ]\",\n \"def load_tweets(brand):\\n\\n api = twitter.Api(\\n consumer_key=os.environ['TWITTER_CONSUMER_KEY'],\\n consumer_secret=os.environ['TWITTER_CONSUMER_SECRET'],\\n access_token_key=os.environ['TWITTER_ACCESS_TOKEN_KEY'],\\n access_token_secret=os.environ['TWITTER_ACCESS_TOKEN_SECRET'])\\n\\n twitter_handle = find_twitter_handle(brand)\\n\\n if not twitter_handle:\\n return []\\n else:\\n results = []\\n count = 0\\n\\n # keep querying api for media posts until we get 20 media posts, up to a max of 10 queries\\n while len(results) < 20 and count < 10:\\n if count == 0:\\n # the first time we query, there will not be a max id\\n response = api.GetUserTimeline(screen_name=twitter_handle[1:], include_rts=False, count=200, exclude_replies=True)\\n else:\\n # the subsquent times we query, the max id should be set to the oldest post, which will be tweets_lst[-1]\\n # the next query will get the prior 200 posts prior to that oldest post\\n response = api.GetUserTimeline(screen_name=twitter_handle[1:], max_id=max_id, include_rts=False, count=200, exclude_replies=True)\\n\\n tweets_lst = []\\n\\n for tweet in response:\\n tweets_lst.append(tweet._json)\\n\\n # for each twitter post, search for media in the post and add it to the results list\\n for status in tweets_lst:\\n if \\\"entities\\\" in status:\\n if \\\"media\\\" in status[\\\"entities\\\"]:\\n results.append(status[\\\"entities\\\"][\\\"media\\\"][0][\\\"media_url\\\"])\\n\\n # if there are twitter posts, but less than 20 results, then we should set the max id to the oldest post, and then next time\\n # the loop runs it will query starting from the previously oldest post\\n if len(tweets_lst) > 1:\\n max_id = tweets_lst[-1][\\\"id\\\"]\\n # if there is less than or only one tweet, then return what we already have in the results list\\n else:\\n return results\\n # add one to the count to track we do not exceed the 10 query count\\n count = count + 1\\n return results\",\n \"def process_query(api, query):\\n last_tweet_id = None if 'LastTweetId' not in query else int(query['LastTweetId']['N'])\\n results = api.GetSearch(result_type=\\\"recent\\\", term=query['Term']['S'],\\n count=25, lang=\\\"en\\\", since_id=last_tweet_id)\\n new_tweets = []\\n if results:\\n latest_tweet_id = results[0].id\\n for tweet in results:\\n if last_tweet_id is not None and tweet.id <= last_tweet_id:\\n break\\n new_tweets.append(tweet)\\n store_tweets(query, new_tweets)\\n update_last_tweet(query, latest_tweet_id)\\n return len(new_tweets)\",\n \"def start_end(start_date, end_date):\\n print(\\\"server received request for tobs stats start date to end date...\\\")\\n # correct for dates before the start of our data\\n if start_date < '2010-01-01':\\n start_date = '2010-01-01'\\n # correct for dates beyond the end of our data\\n if end_date > '2017-08-23':\\n end_date = '2017-08-23'\\n range_df = temps_df[(temps_df['date'] >= start_date) & (temps_df['date'] <= end_date)]\\n lowest = range_df['tobs'].min()\\n highest = range_df['tobs'].max()\\n average = range_df['tobs'].mean()\\n output = {'TMIN': lowest, 'TMAX': highest, 'TAVG': average}\\n return jsonify(output)\",\n \"def output_tweets(self):\\n if self.analyzed_tweets is None:\\n return None\\n\\n splitter = 0\\n if (self.output_mode == \\\"days\\\"):\\n splitter = 86400 # 1 day in seconds\\n pass\\n elif (self.output_mode == \\\"weeks\\\"):\\n splitter = 604800 # 1 week in seconds\\n pass\\n elif (self.output_mode == \\\"hours\\\"):\\n splitter = 3600 # 1 hours in seconds\\n pass\\n else:\\n splitter = 300 # 5 minutes in second\\n\\n oldest = self.analyzed_tweets[0].get_date()\\n newest = self.analyzed_tweets[-1].get_date()\\n\\n delta = int(((newest - oldest).total_seconds()) / splitter)\\n\\n tweets_for_bins = list(self.analyzed_tweets)\\n bins = []\\n hour_bin = []\\n for x in xrange(1, delta + 2):\\n upper_limit = oldest + datetime.timedelta(seconds=splitter * x)\\n lower_limit = upper_limit - datetime.timedelta(seconds=splitter)\\n\\n hour_bin = []\\n for tweet in tweets_for_bins:\\n if tweet.get_date() > upper_limit:\\n bins.append(hour_bin)\\n DLOG(\\\"Bin containing \\\" + str(len(hour_bin)) + \\\" tweets\\\")\\n break\\n elif tweet.get_date() < lower_limit:\\n continue\\n else:\\n hour_bin.append(tweet)\\n [tweets_for_bins.remove(t) for t in hour_bin]\\n\\n DLOG(\\\"Bin containing \\\" + str(len(hour_bin)) + \\\" tweets\\\")\\n bins.append(hour_bin)\\n\\n self.output_bins = bins\\n\\n return bins\\n #### Alternate binning ####\\n # if len(analyzed_tweets) < 500:\\n # bin_size = 10\\n # else:\\n # bin_size = int(len(analyzed_tweets) * .02)\\n # bins = []\\n # for count in range(0, int(len(analyzed_tweets) / bin_size)):\\n # pol_bin = [tweet.polarity for tweet in analyzed_tweets[(count * bin_size):((count + 1) * bin_size)]]\\n # bins.append(pol_bin)\\n # DLOG([sum(bin) for bin in bins])\",\n \"def recoverTweets(authors=[], words=[], removeRetweets=False, sortBy='newest',**kwargs):\\n authors = mapToValid(authors)\\n words = mapToValid(words)\\n\\n def getTopNTweets(retrievedTweets, numberOfTweets):\\n \\\"\\\"\\\"Sort the retrievedTweets by sortBy specified and returns the top-N Tweets\\\"\\\"\\\"\\n if sortBy=='newest':\\n retrievedTweets = sorted(retrievedTweets, key=lambda k: k['id'], reverse=True)\\n elif sortBy=='oldest':\\n retrievedTweets = sorted(retrievedTweets, key=lambda k: k['id'],reverse=False)\\n elif sortBy=='favorite_count':\\n retrievedTweets = sorted(retrievedTweets, key=lambda k: k['favorite_count'],reverse=True)\\n elif sortBy=='retweet_count':\\n retrievedTweets = sorted(retrievedTweets, key=lambda k: k['retweet_count'],reverse=True)\\n else:\\n retrievedTweets = random.sample(retrievedTweets, numberOfTweets)\\n return retrievedTweets[:numberOfTweets]\\n\\n def getTweetsByUser(username, maxTweets=1000):\\n \\\"\\\"\\\"Returns a list of (json) objects representing the tweets for a specified Twitter username.\\n If any words is queried, it will filter out every tweet that doesn't contain any of those words.\\\"\\\"\\\"\\n if 'api' not in globals():\\n startTwitterApi(getApiKeys(fileName=\\\"apiConf2.txt\\\"))\\n myTweets=[]\\n if words:\\n apiRes = tweepy.Cursor(api.user_timeline,screen_name=username, count=100, tweet_mode='extended', include_rts=not removeRetweets).items()\\n for tweet in apiRes:\\n if any(containsWord(tweet._json['full_text'],word) for word in words):\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n else:\\n if sortBy=='newest':\\n for tweet in tweepy.Cursor(api.user_timeline,screen_name=username, count=100, tweet_mode='extended', include_rts=not removeRetweets).items(maxTweets):\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n else:\\n for tweet in tweepy.Cursor(api.user_timeline,screen_name=username, count=100, tweet_mode='extended', include_rts=not removeRetweets).items():\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n\\n return getTopNTweets(myTweets, maxTweets)\\n\\n def searchTweets():\\n \\\"\\\"\\\" returns a list of (json) objects representing the tweets retrieved for a specified query.\\n It doesn't work if any authors is specified.\\n Then, startingDate and endingDate cannot be older than one week ago because of Twitter restrictions for standardAPI\\n :reference: https://developer.twitter.com/en/docs/tweets/search/api-reference/get-search-tweets\\n \\\"\\\"\\\"\\n if 'api' not in globals():\\n startTwitterApi(getApiKeys(fileName='apiConf2.txt'))\\n #SEARCHING TWEETS CONTAINING THE HASHTAG \\\"#bitcoin\\\" USING TWEEPY LIBRARY\\n myTweets= []\\n #words=list(map(str,words))\\n if words:\\n myQuery=' OR '.join(words)\\n else:\\n myQuery = '*'\\n if removeRetweets:\\n myQuery += ' - filter:retweets'\\n kwargs['q']=myQuery\\n kwargs['count']=100\\n kwargs['tweet_mode']='extended'\\n if 'startingDate' in kwargs:\\n kwargs['since']=kwargs['startingDate']\\n del(kwargs['startingDate'])\\n if 'endingDate' in kwargs:\\n kwargs['until']=kwargs['endingDate']\\n del(kwargs['endingDate'])\\n if 'maxTweets' in kwargs:\\n del(kwargs['maxTweets'])\\n if sortBy=='newest':\\n for tweet in tweepy.Cursor(api.search, kwargs).items(maxTweets):\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n else:\\n for tweet in tweepy.Cursor(api.search, kwargs).items():\\n tweet._json['text']=tweet._json['full_text']\\n del (tweet._json['full_text'])\\n myTweets.append(tweet._json)\\n return getTopNTweets(myTweets, maxTweets)\\n\\n\\n def getTwitterscraperTweets():\\n \\\"\\\"\\\" returns a list of (json) objects representing the tweets retrieved for the specified inputs.\\n It's very useful to avoid restrictions such as number of requests or dates not older than 7 days ago for twitterAPI (and tweepy).\\n It will call the recoverTweets.sh script to properly query the API by twitterscraper.\\n :reference: https://github.com/taspinar/twitterscraper\\n \\\"\\\"\\\"\\n import subprocess\\n numOfAuthors = len(authors)\\n numOfWords = len(words)\\n callVars = ['./recoverTweets.sh',str(numOfWords),str(numOfAuthors)]\\n callVars.extend([word for word in words]+[author for author in authors])\\n if startingDate:\\n callVars.extend(['-sd',startingDate])\\n if endingDate:\\n callVars.extend(['-ed',endingDate])\\n #if maxTweets:\\n # callVars.extend(['-max',str(maxTweets)])\\n callVars.append(\\\"data/twitterscrapertmp\\\")\\n print(\\\"Querying twitterAPI by using TwitterScraper... (it may take a long time)\\\")\\n subprocess.call(callVars)\\n with open('data/twitterscrapertmp') as json_data:\\n tweets = json.load(json_data)\\n if removeRetweets:\\n tweets = [tweet for tweet in tweets if not isRetweet(tweet)]\\n print(\\\"Query ended. Retrieved: \\\",len(tweets),\\\" tweets\\\")\\n #saveTweets(tweets,outputCollection,onFile=True,onDb=True)\\n os.remove('data/twitterscrapertmp')\\n return tweets\\n\\n\\n if \\\"maxTweets\\\" in kwargs:\\n maxTweets=kwargs['maxTweets']\\n else:\\n maxTweets=1000\\n\\n if len(authors)==0 and len(words)==0:\\n return(\\\"qua\\\") ###call sample function with maxTweets and (if any) dates\\n if 'startingDate' in kwargs or 'endingDate' in kwargs:\\n return getTwitterscraperTweets()\\n\\n if len(authors)!=0:\\n tweets, splits, i = [], splitIntegerIntoIntegers(maxTweets,len(authors)), 0\\n for author in authors:\\n tweets.extend(getTweetsByUser(username=author, maxTweets=splits[i]))\\n i+=1\\n return tweets\\n return getTweets()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8704661","0.76824534","0.7510762","0.7041128","0.6890227","0.6792959","0.6664002","0.66307527","0.65022916","0.6492793","0.64922196","0.6477469","0.6452656","0.6447653","0.6434829","0.6408373","0.6390277","0.63862234","0.6347076","0.6342707","0.6322864","0.62890965","0.62758493","0.6263058","0.621384","0.61119354","0.6081211","0.60539496","0.6006532","0.5988172","0.59684306","0.59465134","0.59418476","0.5928329","0.5925676","0.5899805","0.5883019","0.5877819","0.58701795","0.58571064","0.58286846","0.5818566","0.58141464","0.58103216","0.5807561","0.5797148","0.57949054","0.57929265","0.5771613","0.57714874","0.57685","0.575164","0.574941","0.5745294","0.5745186","0.57316667","0.5711278","0.5707011","0.56673926","0.5664991","0.5644538","0.56402165","0.5619049","0.56145585","0.56084675","0.5607863","0.55778193","0.55710924","0.5548242","0.55459934","0.5544514","0.5538256","0.55320704","0.55089873","0.5503396","0.5498798","0.5495957","0.5490818","0.5468058","0.5438725","0.54237","0.54195905","0.54195255","0.54148346","0.5411077","0.5409951","0.5409053","0.5408299","0.54030645","0.54013926","0.5399751","0.5388016","0.5381623","0.5379232","0.53753185","0.53712153","0.5361363","0.5361278","0.5359674","0.5353277"],"string":"[\n \"0.8704661\",\n \"0.76824534\",\n \"0.7510762\",\n \"0.7041128\",\n \"0.6890227\",\n \"0.6792959\",\n \"0.6664002\",\n \"0.66307527\",\n \"0.65022916\",\n \"0.6492793\",\n \"0.64922196\",\n \"0.6477469\",\n \"0.6452656\",\n \"0.6447653\",\n \"0.6434829\",\n \"0.6408373\",\n \"0.6390277\",\n \"0.63862234\",\n \"0.6347076\",\n \"0.6342707\",\n \"0.6322864\",\n \"0.62890965\",\n \"0.62758493\",\n \"0.6263058\",\n \"0.621384\",\n \"0.61119354\",\n \"0.6081211\",\n \"0.60539496\",\n \"0.6006532\",\n \"0.5988172\",\n \"0.59684306\",\n \"0.59465134\",\n \"0.59418476\",\n \"0.5928329\",\n \"0.5925676\",\n \"0.5899805\",\n \"0.5883019\",\n \"0.5877819\",\n \"0.58701795\",\n \"0.58571064\",\n \"0.58286846\",\n \"0.5818566\",\n \"0.58141464\",\n \"0.58103216\",\n \"0.5807561\",\n \"0.5797148\",\n \"0.57949054\",\n \"0.57929265\",\n \"0.5771613\",\n \"0.57714874\",\n \"0.57685\",\n \"0.575164\",\n \"0.574941\",\n \"0.5745294\",\n \"0.5745186\",\n \"0.57316667\",\n \"0.5711278\",\n \"0.5707011\",\n \"0.56673926\",\n \"0.5664991\",\n \"0.5644538\",\n \"0.56402165\",\n \"0.5619049\",\n \"0.56145585\",\n \"0.56084675\",\n \"0.5607863\",\n \"0.55778193\",\n \"0.55710924\",\n \"0.5548242\",\n \"0.55459934\",\n \"0.5544514\",\n \"0.5538256\",\n \"0.55320704\",\n \"0.55089873\",\n \"0.5503396\",\n \"0.5498798\",\n \"0.5495957\",\n \"0.5490818\",\n \"0.5468058\",\n \"0.5438725\",\n \"0.54237\",\n \"0.54195905\",\n \"0.54195255\",\n \"0.54148346\",\n \"0.5411077\",\n \"0.5409951\",\n \"0.5409053\",\n \"0.5408299\",\n \"0.54030645\",\n \"0.54013926\",\n \"0.5399751\",\n \"0.5388016\",\n \"0.5381623\",\n \"0.5379232\",\n \"0.53753185\",\n \"0.53712153\",\n \"0.5361363\",\n \"0.5361278\",\n \"0.5359674\",\n \"0.5353277\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7896825"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":18598,"cells":{"query":{"kind":"string","value":"Get Seconds from time."},"document":{"kind":"string","value":"def get_sec(time_str):\n h, m, s = time_str.split(':')\n return int(h) * 3600 + int(m) * 60 + int(s)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def to_seconds(time):\n return 3600 * time","def time_to_int(self):\n minutes = self.hour * 60 + self.minute\n seconds = minutes * 60 + self.second\n return seconds","def time_to_int(time):\n minutes = time.hour * 60 + time.minute\n seconds = minutes * 60 + time.second\n return seconds","def get_sec(time):\n m, s = time[-4:-2], time[-2:]\n if time[-4:2] == '' : m = 0\n if time[-2:] == '' : s = 0\n\n return int(m) * 60 + int(s)","def SECOND(time):\n\n return _make_datetime(time).second","def t_sec(self):\n return self.t/self.parameters['time_conversion']","def getSeconds(self, s):\n duration = 0\n \n for i in s.split('-'):\n if 'h' in i: duration = duration + int(i.split('h')[0])*3600\n if 'm' in i: duration = duration + int(i.split('m')[0])*60\n if 's' in i: duration = duration + int(i.split('s')[0])\n \n return duration","def get_sec(time_str):\n h, m, s = time_str.split(':')\n return int(h) * 3600 + int(m) * 60 + int(float(s))","def time2secs( s ):\n t = s.split( ':' )\n nf = len( t )\n if nf == 1:\n # Seconds only!\n secs = int( t[0] )\n elif nf == 2:\n # Minutes & seconds!\n secs = int( t[1] ) + int( t[0] ) * 60\n elif nf == 3:\n # Hours, minutes & seconds!\n secs = int( t[2] ) + int( t[1] ) * 60 + int( t[0] ) * 60 * 60 \n elif nf == 4:\n # Days, hours, minutes, & seconds!\n secs = int( t[3] ) + int( t[2] ) * 60 + int( t[1] ) * 60 * 60\n secs += int( t[0] ) * 60 * 60 * 24\n\n return secs","def time_to_int(self):\n minutes = self.hour * 60 + self.minute\n secconds = self.minute * 60 + self.second\n return secconds","def sec(self):\n # my clock uses seconds internally\n return self.read()","def to_seconds(self):\r\n return self.hours * 3600 + self.minutes * 60 + self.seconds","def get_time_in_seconds(time, time_units):\n min_in_sec = 60\n hour_in_sec = 60 * 60\n day_in_sec = 24 * 60 * 60\n if time is not None and time > 0:\n if time_units in 'minutes':\n return time * min_in_sec\n elif time_units in 'hours':\n return time * hour_in_sec\n elif time_units in 'days':\n return time * day_in_sec\n else:\n return time\n else:\n return 0","def string_time_to_second(time):\n time_split = time.split(':')\n hour = int(time_split[0])\n minute = int(time_split[1])\n second = int(time_split[2])\n return 3600*hour + 60*minute + second","def to_seconds(self):\n return self.hours * 3600 + self.minutes * 60 + self.seconds","def seconds_in(sec):\r\n return int(sec - (hours_in(sec)*3600) - (minutes_in(sec)*60))","def seconds(self):\n end = self.end or timezone.now()\n result = end - self.start\n return result.seconds","def seconds(self):\n return int(self)","def seconds(self):\n return self._seconds","def seconds(self):\n return self._seconds","def convert_time(t):\n minutes = int(t/60)\n seconds = int(t-60*minutes)\n return minutes, seconds","def current_time_seconds(self):\n return int(round(time.time()))","def convert_time_to_seconds(self, time_value):\n time_epoch = []\n mylog.debug('Converting %s to epoch time' % time_value)\n for value in time_value:\n try:\n pattern = ' %I:%M:%S%p'\n time_epoch_mini = int(time.mktime(time.strptime(value, pattern))) \n time_epoch.append(time_epoch_mini)\n except:\n mylog.debug('%s Does not seem to be in format with leading space' % value)\n try:\n pattern = '%I:%M:%S%p'\n time_epoch_mini = int(time.mktime(time.strptime(value, pattern))) \n time_epoch.append(time_epoch_mini)\n except:\n mylog.debug('%s Does not appear to be in format without leading space' % value)\n return time_epoch","def seconds(input=None):\n return int(get(input))","def timeToSec(ts, unit):\n\ttsec = None\n\tif unit == \"s\":\n\t\ttsec = ts\n\telif unit == \"m\":\n\t\ttsec = ts * secInMinute\n\telif unit == \"h\":\n\t\ttsec = ts * secInHour\n\telif unit == \"d\":\n\t\ttsec = ts * secInDay\n\telse:\n\t\traise exisWithMsg(\"invalid time unit\")\n\n\treturn tsec","def to_seconds(hours, minutes, seconds):\n return hours*60**2 + minutes*60 + seconds","def _current_time_seconds(self):\n return int(round(time.time()))","def parse_time(value):\n # allow an empty value\n if value == '':\n return 0\n\n # seconds should be always 0\n # minutes should be always 1 ecc.\n parts = value.split(':')\n if len(parts) > 4:\n raise ValueError('The provided time does not respect the supported formats: SS, MM:SS, HH:MM:SS, DD:HH:MM:SS.')\n\n parts.reverse()\n seconds = float(parts[0])\n\n # minutes (mm:ss)\n if len(parts) > 1:\n seconds += int(parts[1]) * 60\n\n # hours (hh:mm:ss)\n if len(parts) > 2:\n seconds += float(parts[2]) * 3600\n\n # days (dd:hh:mm:ss)\n if len(parts) > 3:\n seconds += float(parts[3]) * 86400\n\n return seconds","def to_seconds(hours, minutes, seconds):\n return hours*3600+minutes*60+seconds","def datumToSeconds(timestr):\n return (datetime.datetime(int(timestr.split(\"-\")[0]), \n int(timestr.split(\"-\")[1]), \n int(timestr.split(\"-\")[2])) - datetime.datetime(1970,1,1)).total_seconds()","def video_time():\r\n # The full time has the form \"0:32 / 3:14\"\r\n full_time = world.css_text('div.vidtime')\r\n\r\n # Split the time at the \" / \", to get [\"0:32\", \"3:14\"]\r\n elapsed_str, duration_str = full_time.split(' / ')\r\n\r\n # Convert each string to seconds\r\n return (parse_time_str(elapsed_str), parse_time_str(duration_str))","def to_seconds(hours,minutes,seconds):\n return hours*3600+minutes*60+seconds","def seconds(duration):\n if not duration:\n return 0\n try:\n h, m, s = duration_parts(duration)\n return s\n except (ValueError, TypeError):\n return 0","def currentTimeSecs():\n return time.time()","def to_seconds(v):\n m = 1\n if v.endswith(\"h\"):\n v = v[:-1]\n m = 3600\n elif v.endswith(\"d\"):\n v = v[:-1]\n m = 24 * 3600\n elif v.endswith(\"w\"):\n v = v[:-1]\n m = 7 * 24 * 3600\n elif v.endswith(\"m\"):\n v = v[:-1]\n m = 30 * 24 * 3600\n elif v.endswith(\"y\"):\n v = v[:-1]\n m = 365 * 24 * 3600\n try:\n v = int(v)\n except ValueError:\n raise \"Invalid time: %s\" % v\n return v * m","def get_seconds(option):\n sec_option = [\"s\", \"sec\", \"secs\"]\n min_option = [\"m\", \"min\", \"mins\"]\n hr_option = [\"h\", \"hour\", \"hours\"]\n day_option = [\"d\", \"day\", \"days\"]\n if option[1] in sec_option:\n return int(option[0])\n elif option[1] in min_option:\n return int(option[0]) * 60\n elif option[1] in hr_option:\n return int(option[0]) * 3600\n elif option[1] in day_option:\n return int(option[0]) * 216000\n else:\n sys.exit(\"Error {0} is not accepted\".format(option[1]))","def unit_sec(self):\n return self.time_base / 60.0","def get_remaining_seconds(str_time):\n current_time = datetime.utcnow().strftime('%H:%M')\n # 10_800 - the difference in seconds from Moscow (3 hours)\n return (datetime.strptime(str_time, '%H:%M') - datetime.strptime(current_time, '%H:%M')).seconds - 10_800","def convert_time_to_second(time_string):\n return int(time.mktime(time.strptime(time_string, TIME_PATTERN)))","def get_elapsed_seconds():\n\tutcnow = datetime.utcnow()\n\tmidnight_utc = datetime.combine(utcnow.date(), time(0))\n\tdelta = utcnow - midnight_utc\n\treturn delta.total_seconds()","def get_time_sec(gpx_track):\n start_time = gpx_track.segments[0].points[0].time\n time_in_sec = np.empty([gpx_track.get_points_no(), 1])\n n = 1\n for segment in gpx_track.segments:\n for point in segment.points:\n curr_time = point.time\n time_in_sec[n] = curr_time - start_time\n n = n + 1\n\n return time_in_sec, start_time","def heure_to_sec(h: int, m: int, s: int) -> int:\n\n return (h * 3600) + (m * 60) + s","def time2secs(time_str):\r\n try:\r\n time_str = float(time_str)\r\n return get_simple_digit_str(time_str)\r\n except:\r\n pass\r\n try:\r\n final_secs = 0\r\n new_time = re.split(\"\\s+\", time_str)\r\n day_hour_min_sec = {\"days\" : 24*3600, \"hrs\" : 3600, \"mins\" : 60, \"secs\" : 1}\r\n _keys = (\"days\", \"hrs\", \"mins\", \"secs\")\r\n if len(new_time) == 1: # 01:02:03:04 or 01h:02m:03s\r\n new_time = re.split(\":\", time_str)\r\n new_time = [re.sub(\"\\s+\", \"\", item) for item in new_time]\r\n new_time = [re.sub(\"\\D\", \"\", item) for item in new_time]\r\n new_time = [float(item) for item in new_time]\r\n dhms_dict = dict(list(zip(_keys[-len(new_time):], new_time)))\r\n else:\r\n dhms_dict = dict.fromkeys(_keys, 0)\r\n for i, t in enumerate(new_time):\r\n if t in dhms_dict:\r\n dhms_dict[t] = float(new_time[i-1])\r\n for key, value in list(day_hour_min_sec.items()):\r\n my_value = dhms_dict.get(key)\r\n if my_value:\r\n final_secs += my_value * value\r\n return get_simple_digit_str(final_secs)\r\n except (KeyError, ValueError):\r\n return time_str","def as_seconds(*, seconds=0, minutes=0, hours=0, days=0, weeks=0, milliseconds=0, as_type=None):\n delta = datetime.timedelta(seconds=seconds, minutes=minutes, hours=hours,\n days=days, weeks=weeks, milliseconds=milliseconds)\n seconds = delta.total_seconds()\n frac, intpart = math.modf(seconds)\n if frac == 0.0:\n seconds = int(intpart)\n if as_type is not None:\n seconds = as_type(seconds)\n return seconds","def seconds_since_midnight(time):\n return time.hour * 3600 + time.minute * 60 + time.second","def total_seconds_datetime(time):\n if isinstance(time, datetime):\n return time.second + time.minute * 60 + time.hour * 3600\n else:\n raise Exception(\"{} is not a datetime instance\".format(today))","def elapsed_time_in_seconds(self):\n return self._elapsed_time_in_seconds","def to_secs(h,m,s):\r\n h_sec=h*3600\r\n m_sec=m*60\r\n return int(h_sec+m_sec+s)","def convert_time(time_passed):\n\n minutes = time_passed.seconds // 60\n\n return minutes","def __parseTimeArg(self, timeStr):\n \n # Number of seconds.\n retVal = 0\n \n ### NOT YET IMPLEMENTED. NEEDS TO BE DONE!\n \n \n return retVal","def str2seconds(strtime):\n\n result = 0\n\n for i in re.split(r\"([0-9]+[a-z]+)\", strtime):\n\n stri = i.strip().lower() # Case insensitive\n if not stri:\n continue\n\n digits = \"\".join([i for i in stri if i.isdigit()])\n\n if len(stri) == len(digits): # Without symbol assume seconds\n result += int(digits)\n elif len(stri) > len(digits) + 1: # Only one symbol number\n result += 0\n elif 'd' in stri: # Days\n result += 86400 * int(digits)\n elif 'h' in stri: # Hours\n result += 3600 * int(digits)\n elif 'm' in stri: # Minutes\n result += 60 * int(digits)\n elif 's' in stri: # Seconds\n result += int(digits)\n\n return result","def GetTotalSeconds(self):\n if not self.Complete():\n raise DateTimeError(\"GetTotalSeconds requires complete precision\")\n if self.second == 60:\n return 59 + self.minute * 60 + self.hour * 3600\n else:\n return self.second + self.minute * 60 + self.hour * 3600","def _unit_sec(self):\n return self.time_base / 60.0","def get_seconds(self):\n return self.seconds_remaining","def total_seconds(self):\n return (\n (self.days * 86400 + self.seconds) * 10**6 + self.microseconds\n ) / 10**6","def time_difference_in_seconds(readings: List[Reading]) -> int:\n initial, final = latest_two_readings(readings)\n seconds = (final.timestamp - initial.timestamp).total_seconds()\n if seconds == 0:\n raise UsageEstimatorError(\"Two readings taken at the exact same second\")\n\n return int(seconds)","def _get_time(self, sec, nsec):\n return sec + nsec / (10**9)","def parse_time(time_string):\n minutes = re.search(r\"(\\d+) minutes\", time_string)\n if minutes:\n minutes = int(minutes.groups()[0])\n else:\n minutes = 0\n\n seconds = re.search(r\"(\\d+\\.\\d+) seconds\", time_string)\n if seconds:\n seconds = float(seconds.groups()[0])\n else:\n seconds = 0.0\n\n seconds += minutes * 60\n\n return seconds","def timestamp2sec(timestamp):\n return (int(timestamp.seconds) + 60 * int(timestamp.minutes) + 3600 * int(timestamp.hours) + float(int(timestamp.hours) / 1000))","def sweep_time(self):\n time = self._pna.query('sense{}:sweep:time?'.format(self._channel))\n if time:\n return float(time)\n else:\n raise InstrIOError(cleandoc('''Agilent PNA did not return the\n channel {} sweep point number'''.format(self._channel)))","def parse_time_interval_seconds(time_str):\n cal = parsedatetime.Calendar()\n parse_result = cal.parseDT(time_str, sourceTime=datetime.min)\n if parse_result[1] == 0:\n raise ValueError(\"Could not understand time {time}\".format(time=time_str))\n return (parse_result[0] - datetime.min).total_seconds()","def MillisToSec(self):\n self.Millis = [item / 1000 for item in self.Millis]\n return self.Millis","def get_time_taken_sec(self) -> float:\n return self.time_stop - self.time_start","def hours_minutes_seconds(value):\n try:\n return int(value)\n except ValueError:\n pass\n\n match = (_hours_minutes_seconds_re.match(value)\n or _hours_minutes_seconds_2_re.match(value))\n if not match:\n raise ValueError\n\n s = 0\n s += int(match.group(\"hours\") or \"0\") * 60 * 60\n s += int(match.group(\"minutes\") or \"0\") * 60\n s += int(match.group(\"seconds\") or \"0\")\n\n return s","def _get_milleseconds(self):\n return int(round(time.time() * 1000))","def duration_in_seconds(self):\n return self.get_data(\"duration_in_seconds\")","def get_full_secs(self):\n return _uhd_swig.time_spec_t_get_full_secs(self)","def total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6","def getSecondsFromStringDateTime(date_time):\n split_date_time = date_time.split(Constants.record_name_sep)\n if len(split_date_time) == 5:\n for value in split_date_time:\n if not isNumber(value):\n return Constants.return_value_invalid_datetime_value\n result = int(split_date_time[0]) * 31622400 # Year in seconds\n result += int(split_date_time[1]) * 2592000 # Month in seconds\n result += int(split_date_time[2]) * 86400 # Day in seconds\n result += int(split_date_time[3]) * 3600 # Hour in seconds\n result += int(split_date_time[4]) * 60 # Minute in seconds\n return result\n else:\n return Constants.return_value_invalid_datetime_value","def minutes_to_seconds(minutes):\n return minutes * 60","def _to_seconds(value, unit):\n if (not isinstance(value, int)) or (not isinstance(unit, int)):\n raise InstrumentProtocolException(\"Invalid second arguments!\")\n \n if unit == 1:\n return value * 60\n elif unit == 0:\n return value\n else:\n raise InstrumentProtocolException(\"Invalid Units!\")","def get_time(cls):\n now = rospy.Time.now()\n return now.secs + now.nsecs*(10**-9) # time in seconds","def get_real_secs(self):\n return _uhd_swig.time_spec_t_get_real_secs(self)","def parse_time_ms(time_string):\n try:\n return int(1000 * parse_duration(time_string))\n except:\n logging.exception('Unable to extract seconds from {}'.format(time_string))\n logging.info('Defaulting time to 1 second.')\n return 1000","def get_total_seconds(td):\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6","def get_time(self):\n return self.get_timed() / 10.0","def minutes_to_seconds( minutes: str ) -> int:\r\n return int(minutes)*60","def time(self) -> int:\n return self.raw[\"time\"]","def calculate_seconds_in_hours(hours):\n return int(hours * 3600)","def test_time_to_seconds(self):\n correct_time = \"1970-01-01T00:00:05+00:00\"\n wrong_time = \"1/1/1970 00:00:03\"\n self.assertEqual(time_to_seconds(correct_time), 5)\n self.assertFalse(time_to_seconds(wrong_time))","def get_duration(self):\n seconds = self.duration.total_seconds()\n mins, secs = divmod(seconds, 60)\n return int(mins), int(secs)","def sec2hms(seconds):\n hours, seconds = divmod(seconds, 60**2)\n minutes, seconds = divmod(seconds, 60)\n return int(hours), int(minutes), seconds","def get_time_ms():\n return int(round(time.time() * 1000))","def minutes_to_seconds(minutes) -> int:\n return int(minutes) * 60","def hours_in(sec):\r\n return int(sec//3600)","def get_hours_and_minutes(time):\n\n # Get the total seconds of the time object\n totalseconds = time.total_seconds()\n \n # Find the total hours in the time object\n totalhours = totalseconds//3600\n # Find the total minutes in the time object\n totalminutes = (totalseconds%3600) // 60 \n\n # Return a list composing of the total hours and minutes\n return [totalhours,totalminutes]","def parse_time(s):\n if s[-1].lower() in secs:\n return int(s[:-1]) * secs[s[-1].lower()]\n else:\n return int(s)","def parse_timespan(timedef):\n\tif isinstance(timedef, int):\n\t\treturn timedef\n\tconverter_order = ('w', 'd', 'h', 'm', 's')\n\tconverters = {\n\t\t'w': 604800,\n\t\t'd': 86400,\n\t\t'h': 3600,\n\t\t'm': 60,\n\t\t's': 1\n\t}\n\ttimedef = timedef.lower()\n\tif timedef.isdigit():\n\t\treturn int(timedef)\n\telif len(timedef) == 0:\n\t\treturn 0\n\tseconds = -1\n\tfor spec in converter_order:\n\t\ttimedef = timedef.split(spec)\n\t\tif len(timedef) == 1:\n\t\t\ttimedef = timedef[0]\n\t\t\tcontinue\n\t\telif len(timedef) > 2 or not timedef[0].isdigit():\n\t\t\tseconds = -1\n\t\t\tbreak\n\t\tadjustment = converters[spec]\n\t\tseconds = max(seconds, 0)\n\t\tseconds += (int(timedef[0]) * adjustment)\n\t\ttimedef = timedef[1]\n\t\tif not len(timedef):\n\t\t\tbreak\n\tif seconds < 0:\n\t\traise ValueError('invalid time format')\n\treturn seconds","def convert_from_seconds(s):\n days = s // (24 * 3600) #Het aantal dagen\n time = s % (24 * 3600)\n hours = time // 3600\n time %= 3600\n minutes = time // 60\n time %= 60\n seconds = time\n return [days, hours, minutes, seconds]","def _duration_to_secs(duration):\n secs = int(duration[:-1])\n if duration[-1] == 's':\n pass\n elif duration[-1] == 'm':\n secs *= 60\n elif duration[-1] == 'h':\n secs *= 60 * 60\n elif duration[-1] == 'd':\n secs *= 60 * 60 * 24\n else:\n raise ValueError('Invalid duration: %r' % duration)\n\n return secs","def daysToSeconds(dayInt):\n return dayInt * 24 * 60 * 60","def get_seconds(interval):\n if type(interval) is str:\n interval_array = interval.split(' ')\n try:\n seconds = int(interval_array[0]) * TIME_SCALES[interval_array[1]]\n except KeyError:\n raise ValueError(\n \"Valid time scales are: {}\".format(list(TIME_SCALES.keys()))\n )\n except ValueError:\n raise ValueError(\n '''\n Invalid format in time scale. It must include an integer\n followed by a string.\n Try a format like this: '1 minute'.\n '''\n )\n else:\n return seconds\n\n elif isinstance(interval, (int, float)) or interval is None:\n return interval\n\n else:\n raise TypeError(\n \"Time intervals can only be a string, an integer or a float.\"\n )","def time(self):\n return self.raw() % (60 * 24)","def int_to_time(seconds):\n time = Time()\n minutes, time.second = divmod(seconds, 60)\n time.hour, time.minute = divmod(minutes, 60)\n return time","def parse_timestr(self, timestr):\n\n epoch = datetime.datetime(1970, 1, 1, 0, 0, 0, 0, tzutc())\n return int((parsedate(timestr) - epoch).total_seconds())","def total_seconds(self):\n return 0","def time_to_sec(duration):\r\n duration, unit = val_to_type_unit(duration)\r\n if unit in ['h', 'hr', 'hrs', 'hours', 'hour']:\r\n duration *= 60 * 60\r\n elif unit in ['m', 'min', 'mins', 'minutes', 'minute']:\r\n duration *= 60\r\n elif unit in [None, 's', 'sec', 'secs', 'seconds', 'second']:\r\n pass\r\n else:\r\n raise ValueError('Unrecognized time unit: %s' % unit)\r\n\r\n return duration","def seconds_calc(delta):\n return (delta.hours * 3600) + (delta.minutes * 60) + delta.seconds","def time_calculator(seconds):\n seconds = int(seconds)\n days = seconds // 86400\n hours = seconds % 86400 // 3600\n minutes = seconds % 86400 % 3600 // 60\n seconds = seconds % 86400 % 3600 % 60\n time_list = [days, hours, minutes, seconds] # Created a list that stores these variables in order\n return time_list"],"string":"[\n \"def to_seconds(time):\\n return 3600 * time\",\n \"def time_to_int(self):\\n minutes = self.hour * 60 + self.minute\\n seconds = minutes * 60 + self.second\\n return seconds\",\n \"def time_to_int(time):\\n minutes = time.hour * 60 + time.minute\\n seconds = minutes * 60 + time.second\\n return seconds\",\n \"def get_sec(time):\\n m, s = time[-4:-2], time[-2:]\\n if time[-4:2] == '' : m = 0\\n if time[-2:] == '' : s = 0\\n\\n return int(m) * 60 + int(s)\",\n \"def SECOND(time):\\n\\n return _make_datetime(time).second\",\n \"def t_sec(self):\\n return self.t/self.parameters['time_conversion']\",\n \"def getSeconds(self, s):\\n duration = 0\\n \\n for i in s.split('-'):\\n if 'h' in i: duration = duration + int(i.split('h')[0])*3600\\n if 'm' in i: duration = duration + int(i.split('m')[0])*60\\n if 's' in i: duration = duration + int(i.split('s')[0])\\n \\n return duration\",\n \"def get_sec(time_str):\\n h, m, s = time_str.split(':')\\n return int(h) * 3600 + int(m) * 60 + int(float(s))\",\n \"def time2secs( s ):\\n t = s.split( ':' )\\n nf = len( t )\\n if nf == 1:\\n # Seconds only!\\n secs = int( t[0] )\\n elif nf == 2:\\n # Minutes & seconds!\\n secs = int( t[1] ) + int( t[0] ) * 60\\n elif nf == 3:\\n # Hours, minutes & seconds!\\n secs = int( t[2] ) + int( t[1] ) * 60 + int( t[0] ) * 60 * 60 \\n elif nf == 4:\\n # Days, hours, minutes, & seconds!\\n secs = int( t[3] ) + int( t[2] ) * 60 + int( t[1] ) * 60 * 60\\n secs += int( t[0] ) * 60 * 60 * 24\\n\\n return secs\",\n \"def time_to_int(self):\\n minutes = self.hour * 60 + self.minute\\n secconds = self.minute * 60 + self.second\\n return secconds\",\n \"def sec(self):\\n # my clock uses seconds internally\\n return self.read()\",\n \"def to_seconds(self):\\r\\n return self.hours * 3600 + self.minutes * 60 + self.seconds\",\n \"def get_time_in_seconds(time, time_units):\\n min_in_sec = 60\\n hour_in_sec = 60 * 60\\n day_in_sec = 24 * 60 * 60\\n if time is not None and time > 0:\\n if time_units in 'minutes':\\n return time * min_in_sec\\n elif time_units in 'hours':\\n return time * hour_in_sec\\n elif time_units in 'days':\\n return time * day_in_sec\\n else:\\n return time\\n else:\\n return 0\",\n \"def string_time_to_second(time):\\n time_split = time.split(':')\\n hour = int(time_split[0])\\n minute = int(time_split[1])\\n second = int(time_split[2])\\n return 3600*hour + 60*minute + second\",\n \"def to_seconds(self):\\n return self.hours * 3600 + self.minutes * 60 + self.seconds\",\n \"def seconds_in(sec):\\r\\n return int(sec - (hours_in(sec)*3600) - (minutes_in(sec)*60))\",\n \"def seconds(self):\\n end = self.end or timezone.now()\\n result = end - self.start\\n return result.seconds\",\n \"def seconds(self):\\n return int(self)\",\n \"def seconds(self):\\n return self._seconds\",\n \"def seconds(self):\\n return self._seconds\",\n \"def convert_time(t):\\n minutes = int(t/60)\\n seconds = int(t-60*minutes)\\n return minutes, seconds\",\n \"def current_time_seconds(self):\\n return int(round(time.time()))\",\n \"def convert_time_to_seconds(self, time_value):\\n time_epoch = []\\n mylog.debug('Converting %s to epoch time' % time_value)\\n for value in time_value:\\n try:\\n pattern = ' %I:%M:%S%p'\\n time_epoch_mini = int(time.mktime(time.strptime(value, pattern))) \\n time_epoch.append(time_epoch_mini)\\n except:\\n mylog.debug('%s Does not seem to be in format with leading space' % value)\\n try:\\n pattern = '%I:%M:%S%p'\\n time_epoch_mini = int(time.mktime(time.strptime(value, pattern))) \\n time_epoch.append(time_epoch_mini)\\n except:\\n mylog.debug('%s Does not appear to be in format without leading space' % value)\\n return time_epoch\",\n \"def seconds(input=None):\\n return int(get(input))\",\n \"def timeToSec(ts, unit):\\n\\ttsec = None\\n\\tif unit == \\\"s\\\":\\n\\t\\ttsec = ts\\n\\telif unit == \\\"m\\\":\\n\\t\\ttsec = ts * secInMinute\\n\\telif unit == \\\"h\\\":\\n\\t\\ttsec = ts * secInHour\\n\\telif unit == \\\"d\\\":\\n\\t\\ttsec = ts * secInDay\\n\\telse:\\n\\t\\traise exisWithMsg(\\\"invalid time unit\\\")\\n\\n\\treturn tsec\",\n \"def to_seconds(hours, minutes, seconds):\\n return hours*60**2 + minutes*60 + seconds\",\n \"def _current_time_seconds(self):\\n return int(round(time.time()))\",\n \"def parse_time(value):\\n # allow an empty value\\n if value == '':\\n return 0\\n\\n # seconds should be always 0\\n # minutes should be always 1 ecc.\\n parts = value.split(':')\\n if len(parts) > 4:\\n raise ValueError('The provided time does not respect the supported formats: SS, MM:SS, HH:MM:SS, DD:HH:MM:SS.')\\n\\n parts.reverse()\\n seconds = float(parts[0])\\n\\n # minutes (mm:ss)\\n if len(parts) > 1:\\n seconds += int(parts[1]) * 60\\n\\n # hours (hh:mm:ss)\\n if len(parts) > 2:\\n seconds += float(parts[2]) * 3600\\n\\n # days (dd:hh:mm:ss)\\n if len(parts) > 3:\\n seconds += float(parts[3]) * 86400\\n\\n return seconds\",\n \"def to_seconds(hours, minutes, seconds):\\n return hours*3600+minutes*60+seconds\",\n \"def datumToSeconds(timestr):\\n return (datetime.datetime(int(timestr.split(\\\"-\\\")[0]), \\n int(timestr.split(\\\"-\\\")[1]), \\n int(timestr.split(\\\"-\\\")[2])) - datetime.datetime(1970,1,1)).total_seconds()\",\n \"def video_time():\\r\\n # The full time has the form \\\"0:32 / 3:14\\\"\\r\\n full_time = world.css_text('div.vidtime')\\r\\n\\r\\n # Split the time at the \\\" / \\\", to get [\\\"0:32\\\", \\\"3:14\\\"]\\r\\n elapsed_str, duration_str = full_time.split(' / ')\\r\\n\\r\\n # Convert each string to seconds\\r\\n return (parse_time_str(elapsed_str), parse_time_str(duration_str))\",\n \"def to_seconds(hours,minutes,seconds):\\n return hours*3600+minutes*60+seconds\",\n \"def seconds(duration):\\n if not duration:\\n return 0\\n try:\\n h, m, s = duration_parts(duration)\\n return s\\n except (ValueError, TypeError):\\n return 0\",\n \"def currentTimeSecs():\\n return time.time()\",\n \"def to_seconds(v):\\n m = 1\\n if v.endswith(\\\"h\\\"):\\n v = v[:-1]\\n m = 3600\\n elif v.endswith(\\\"d\\\"):\\n v = v[:-1]\\n m = 24 * 3600\\n elif v.endswith(\\\"w\\\"):\\n v = v[:-1]\\n m = 7 * 24 * 3600\\n elif v.endswith(\\\"m\\\"):\\n v = v[:-1]\\n m = 30 * 24 * 3600\\n elif v.endswith(\\\"y\\\"):\\n v = v[:-1]\\n m = 365 * 24 * 3600\\n try:\\n v = int(v)\\n except ValueError:\\n raise \\\"Invalid time: %s\\\" % v\\n return v * m\",\n \"def get_seconds(option):\\n sec_option = [\\\"s\\\", \\\"sec\\\", \\\"secs\\\"]\\n min_option = [\\\"m\\\", \\\"min\\\", \\\"mins\\\"]\\n hr_option = [\\\"h\\\", \\\"hour\\\", \\\"hours\\\"]\\n day_option = [\\\"d\\\", \\\"day\\\", \\\"days\\\"]\\n if option[1] in sec_option:\\n return int(option[0])\\n elif option[1] in min_option:\\n return int(option[0]) * 60\\n elif option[1] in hr_option:\\n return int(option[0]) * 3600\\n elif option[1] in day_option:\\n return int(option[0]) * 216000\\n else:\\n sys.exit(\\\"Error {0} is not accepted\\\".format(option[1]))\",\n \"def unit_sec(self):\\n return self.time_base / 60.0\",\n \"def get_remaining_seconds(str_time):\\n current_time = datetime.utcnow().strftime('%H:%M')\\n # 10_800 - the difference in seconds from Moscow (3 hours)\\n return (datetime.strptime(str_time, '%H:%M') - datetime.strptime(current_time, '%H:%M')).seconds - 10_800\",\n \"def convert_time_to_second(time_string):\\n return int(time.mktime(time.strptime(time_string, TIME_PATTERN)))\",\n \"def get_elapsed_seconds():\\n\\tutcnow = datetime.utcnow()\\n\\tmidnight_utc = datetime.combine(utcnow.date(), time(0))\\n\\tdelta = utcnow - midnight_utc\\n\\treturn delta.total_seconds()\",\n \"def get_time_sec(gpx_track):\\n start_time = gpx_track.segments[0].points[0].time\\n time_in_sec = np.empty([gpx_track.get_points_no(), 1])\\n n = 1\\n for segment in gpx_track.segments:\\n for point in segment.points:\\n curr_time = point.time\\n time_in_sec[n] = curr_time - start_time\\n n = n + 1\\n\\n return time_in_sec, start_time\",\n \"def heure_to_sec(h: int, m: int, s: int) -> int:\\n\\n return (h * 3600) + (m * 60) + s\",\n \"def time2secs(time_str):\\r\\n try:\\r\\n time_str = float(time_str)\\r\\n return get_simple_digit_str(time_str)\\r\\n except:\\r\\n pass\\r\\n try:\\r\\n final_secs = 0\\r\\n new_time = re.split(\\\"\\\\s+\\\", time_str)\\r\\n day_hour_min_sec = {\\\"days\\\" : 24*3600, \\\"hrs\\\" : 3600, \\\"mins\\\" : 60, \\\"secs\\\" : 1}\\r\\n _keys = (\\\"days\\\", \\\"hrs\\\", \\\"mins\\\", \\\"secs\\\")\\r\\n if len(new_time) == 1: # 01:02:03:04 or 01h:02m:03s\\r\\n new_time = re.split(\\\":\\\", time_str)\\r\\n new_time = [re.sub(\\\"\\\\s+\\\", \\\"\\\", item) for item in new_time]\\r\\n new_time = [re.sub(\\\"\\\\D\\\", \\\"\\\", item) for item in new_time]\\r\\n new_time = [float(item) for item in new_time]\\r\\n dhms_dict = dict(list(zip(_keys[-len(new_time):], new_time)))\\r\\n else:\\r\\n dhms_dict = dict.fromkeys(_keys, 0)\\r\\n for i, t in enumerate(new_time):\\r\\n if t in dhms_dict:\\r\\n dhms_dict[t] = float(new_time[i-1])\\r\\n for key, value in list(day_hour_min_sec.items()):\\r\\n my_value = dhms_dict.get(key)\\r\\n if my_value:\\r\\n final_secs += my_value * value\\r\\n return get_simple_digit_str(final_secs)\\r\\n except (KeyError, ValueError):\\r\\n return time_str\",\n \"def as_seconds(*, seconds=0, minutes=0, hours=0, days=0, weeks=0, milliseconds=0, as_type=None):\\n delta = datetime.timedelta(seconds=seconds, minutes=minutes, hours=hours,\\n days=days, weeks=weeks, milliseconds=milliseconds)\\n seconds = delta.total_seconds()\\n frac, intpart = math.modf(seconds)\\n if frac == 0.0:\\n seconds = int(intpart)\\n if as_type is not None:\\n seconds = as_type(seconds)\\n return seconds\",\n \"def seconds_since_midnight(time):\\n return time.hour * 3600 + time.minute * 60 + time.second\",\n \"def total_seconds_datetime(time):\\n if isinstance(time, datetime):\\n return time.second + time.minute * 60 + time.hour * 3600\\n else:\\n raise Exception(\\\"{} is not a datetime instance\\\".format(today))\",\n \"def elapsed_time_in_seconds(self):\\n return self._elapsed_time_in_seconds\",\n \"def to_secs(h,m,s):\\r\\n h_sec=h*3600\\r\\n m_sec=m*60\\r\\n return int(h_sec+m_sec+s)\",\n \"def convert_time(time_passed):\\n\\n minutes = time_passed.seconds // 60\\n\\n return minutes\",\n \"def __parseTimeArg(self, timeStr):\\n \\n # Number of seconds.\\n retVal = 0\\n \\n ### NOT YET IMPLEMENTED. NEEDS TO BE DONE!\\n \\n \\n return retVal\",\n \"def str2seconds(strtime):\\n\\n result = 0\\n\\n for i in re.split(r\\\"([0-9]+[a-z]+)\\\", strtime):\\n\\n stri = i.strip().lower() # Case insensitive\\n if not stri:\\n continue\\n\\n digits = \\\"\\\".join([i for i in stri if i.isdigit()])\\n\\n if len(stri) == len(digits): # Without symbol assume seconds\\n result += int(digits)\\n elif len(stri) > len(digits) + 1: # Only one symbol number\\n result += 0\\n elif 'd' in stri: # Days\\n result += 86400 * int(digits)\\n elif 'h' in stri: # Hours\\n result += 3600 * int(digits)\\n elif 'm' in stri: # Minutes\\n result += 60 * int(digits)\\n elif 's' in stri: # Seconds\\n result += int(digits)\\n\\n return result\",\n \"def GetTotalSeconds(self):\\n if not self.Complete():\\n raise DateTimeError(\\\"GetTotalSeconds requires complete precision\\\")\\n if self.second == 60:\\n return 59 + self.minute * 60 + self.hour * 3600\\n else:\\n return self.second + self.minute * 60 + self.hour * 3600\",\n \"def _unit_sec(self):\\n return self.time_base / 60.0\",\n \"def get_seconds(self):\\n return self.seconds_remaining\",\n \"def total_seconds(self):\\n return (\\n (self.days * 86400 + self.seconds) * 10**6 + self.microseconds\\n ) / 10**6\",\n \"def time_difference_in_seconds(readings: List[Reading]) -> int:\\n initial, final = latest_two_readings(readings)\\n seconds = (final.timestamp - initial.timestamp).total_seconds()\\n if seconds == 0:\\n raise UsageEstimatorError(\\\"Two readings taken at the exact same second\\\")\\n\\n return int(seconds)\",\n \"def _get_time(self, sec, nsec):\\n return sec + nsec / (10**9)\",\n \"def parse_time(time_string):\\n minutes = re.search(r\\\"(\\\\d+) minutes\\\", time_string)\\n if minutes:\\n minutes = int(minutes.groups()[0])\\n else:\\n minutes = 0\\n\\n seconds = re.search(r\\\"(\\\\d+\\\\.\\\\d+) seconds\\\", time_string)\\n if seconds:\\n seconds = float(seconds.groups()[0])\\n else:\\n seconds = 0.0\\n\\n seconds += minutes * 60\\n\\n return seconds\",\n \"def timestamp2sec(timestamp):\\n return (int(timestamp.seconds) + 60 * int(timestamp.minutes) + 3600 * int(timestamp.hours) + float(int(timestamp.hours) / 1000))\",\n \"def sweep_time(self):\\n time = self._pna.query('sense{}:sweep:time?'.format(self._channel))\\n if time:\\n return float(time)\\n else:\\n raise InstrIOError(cleandoc('''Agilent PNA did not return the\\n channel {} sweep point number'''.format(self._channel)))\",\n \"def parse_time_interval_seconds(time_str):\\n cal = parsedatetime.Calendar()\\n parse_result = cal.parseDT(time_str, sourceTime=datetime.min)\\n if parse_result[1] == 0:\\n raise ValueError(\\\"Could not understand time {time}\\\".format(time=time_str))\\n return (parse_result[0] - datetime.min).total_seconds()\",\n \"def MillisToSec(self):\\n self.Millis = [item / 1000 for item in self.Millis]\\n return self.Millis\",\n \"def get_time_taken_sec(self) -> float:\\n return self.time_stop - self.time_start\",\n \"def hours_minutes_seconds(value):\\n try:\\n return int(value)\\n except ValueError:\\n pass\\n\\n match = (_hours_minutes_seconds_re.match(value)\\n or _hours_minutes_seconds_2_re.match(value))\\n if not match:\\n raise ValueError\\n\\n s = 0\\n s += int(match.group(\\\"hours\\\") or \\\"0\\\") * 60 * 60\\n s += int(match.group(\\\"minutes\\\") or \\\"0\\\") * 60\\n s += int(match.group(\\\"seconds\\\") or \\\"0\\\")\\n\\n return s\",\n \"def _get_milleseconds(self):\\n return int(round(time.time() * 1000))\",\n \"def duration_in_seconds(self):\\n return self.get_data(\\\"duration_in_seconds\\\")\",\n \"def get_full_secs(self):\\n return _uhd_swig.time_spec_t_get_full_secs(self)\",\n \"def total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6\",\n \"def getSecondsFromStringDateTime(date_time):\\n split_date_time = date_time.split(Constants.record_name_sep)\\n if len(split_date_time) == 5:\\n for value in split_date_time:\\n if not isNumber(value):\\n return Constants.return_value_invalid_datetime_value\\n result = int(split_date_time[0]) * 31622400 # Year in seconds\\n result += int(split_date_time[1]) * 2592000 # Month in seconds\\n result += int(split_date_time[2]) * 86400 # Day in seconds\\n result += int(split_date_time[3]) * 3600 # Hour in seconds\\n result += int(split_date_time[4]) * 60 # Minute in seconds\\n return result\\n else:\\n return Constants.return_value_invalid_datetime_value\",\n \"def minutes_to_seconds(minutes):\\n return minutes * 60\",\n \"def _to_seconds(value, unit):\\n if (not isinstance(value, int)) or (not isinstance(unit, int)):\\n raise InstrumentProtocolException(\\\"Invalid second arguments!\\\")\\n \\n if unit == 1:\\n return value * 60\\n elif unit == 0:\\n return value\\n else:\\n raise InstrumentProtocolException(\\\"Invalid Units!\\\")\",\n \"def get_time(cls):\\n now = rospy.Time.now()\\n return now.secs + now.nsecs*(10**-9) # time in seconds\",\n \"def get_real_secs(self):\\n return _uhd_swig.time_spec_t_get_real_secs(self)\",\n \"def parse_time_ms(time_string):\\n try:\\n return int(1000 * parse_duration(time_string))\\n except:\\n logging.exception('Unable to extract seconds from {}'.format(time_string))\\n logging.info('Defaulting time to 1 second.')\\n return 1000\",\n \"def get_total_seconds(td):\\n return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 1e6) / 1e6\",\n \"def get_time(self):\\n return self.get_timed() / 10.0\",\n \"def minutes_to_seconds( minutes: str ) -> int:\\r\\n return int(minutes)*60\",\n \"def time(self) -> int:\\n return self.raw[\\\"time\\\"]\",\n \"def calculate_seconds_in_hours(hours):\\n return int(hours * 3600)\",\n \"def test_time_to_seconds(self):\\n correct_time = \\\"1970-01-01T00:00:05+00:00\\\"\\n wrong_time = \\\"1/1/1970 00:00:03\\\"\\n self.assertEqual(time_to_seconds(correct_time), 5)\\n self.assertFalse(time_to_seconds(wrong_time))\",\n \"def get_duration(self):\\n seconds = self.duration.total_seconds()\\n mins, secs = divmod(seconds, 60)\\n return int(mins), int(secs)\",\n \"def sec2hms(seconds):\\n hours, seconds = divmod(seconds, 60**2)\\n minutes, seconds = divmod(seconds, 60)\\n return int(hours), int(minutes), seconds\",\n \"def get_time_ms():\\n return int(round(time.time() * 1000))\",\n \"def minutes_to_seconds(minutes) -> int:\\n return int(minutes) * 60\",\n \"def hours_in(sec):\\r\\n return int(sec//3600)\",\n \"def get_hours_and_minutes(time):\\n\\n # Get the total seconds of the time object\\n totalseconds = time.total_seconds()\\n \\n # Find the total hours in the time object\\n totalhours = totalseconds//3600\\n # Find the total minutes in the time object\\n totalminutes = (totalseconds%3600) // 60 \\n\\n # Return a list composing of the total hours and minutes\\n return [totalhours,totalminutes]\",\n \"def parse_time(s):\\n if s[-1].lower() in secs:\\n return int(s[:-1]) * secs[s[-1].lower()]\\n else:\\n return int(s)\",\n \"def parse_timespan(timedef):\\n\\tif isinstance(timedef, int):\\n\\t\\treturn timedef\\n\\tconverter_order = ('w', 'd', 'h', 'm', 's')\\n\\tconverters = {\\n\\t\\t'w': 604800,\\n\\t\\t'd': 86400,\\n\\t\\t'h': 3600,\\n\\t\\t'm': 60,\\n\\t\\t's': 1\\n\\t}\\n\\ttimedef = timedef.lower()\\n\\tif timedef.isdigit():\\n\\t\\treturn int(timedef)\\n\\telif len(timedef) == 0:\\n\\t\\treturn 0\\n\\tseconds = -1\\n\\tfor spec in converter_order:\\n\\t\\ttimedef = timedef.split(spec)\\n\\t\\tif len(timedef) == 1:\\n\\t\\t\\ttimedef = timedef[0]\\n\\t\\t\\tcontinue\\n\\t\\telif len(timedef) > 2 or not timedef[0].isdigit():\\n\\t\\t\\tseconds = -1\\n\\t\\t\\tbreak\\n\\t\\tadjustment = converters[spec]\\n\\t\\tseconds = max(seconds, 0)\\n\\t\\tseconds += (int(timedef[0]) * adjustment)\\n\\t\\ttimedef = timedef[1]\\n\\t\\tif not len(timedef):\\n\\t\\t\\tbreak\\n\\tif seconds < 0:\\n\\t\\traise ValueError('invalid time format')\\n\\treturn seconds\",\n \"def convert_from_seconds(s):\\n days = s // (24 * 3600) #Het aantal dagen\\n time = s % (24 * 3600)\\n hours = time // 3600\\n time %= 3600\\n minutes = time // 60\\n time %= 60\\n seconds = time\\n return [days, hours, minutes, seconds]\",\n \"def _duration_to_secs(duration):\\n secs = int(duration[:-1])\\n if duration[-1] == 's':\\n pass\\n elif duration[-1] == 'm':\\n secs *= 60\\n elif duration[-1] == 'h':\\n secs *= 60 * 60\\n elif duration[-1] == 'd':\\n secs *= 60 * 60 * 24\\n else:\\n raise ValueError('Invalid duration: %r' % duration)\\n\\n return secs\",\n \"def daysToSeconds(dayInt):\\n return dayInt * 24 * 60 * 60\",\n \"def get_seconds(interval):\\n if type(interval) is str:\\n interval_array = interval.split(' ')\\n try:\\n seconds = int(interval_array[0]) * TIME_SCALES[interval_array[1]]\\n except KeyError:\\n raise ValueError(\\n \\\"Valid time scales are: {}\\\".format(list(TIME_SCALES.keys()))\\n )\\n except ValueError:\\n raise ValueError(\\n '''\\n Invalid format in time scale. It must include an integer\\n followed by a string.\\n Try a format like this: '1 minute'.\\n '''\\n )\\n else:\\n return seconds\\n\\n elif isinstance(interval, (int, float)) or interval is None:\\n return interval\\n\\n else:\\n raise TypeError(\\n \\\"Time intervals can only be a string, an integer or a float.\\\"\\n )\",\n \"def time(self):\\n return self.raw() % (60 * 24)\",\n \"def int_to_time(seconds):\\n time = Time()\\n minutes, time.second = divmod(seconds, 60)\\n time.hour, time.minute = divmod(minutes, 60)\\n return time\",\n \"def parse_timestr(self, timestr):\\n\\n epoch = datetime.datetime(1970, 1, 1, 0, 0, 0, 0, tzutc())\\n return int((parsedate(timestr) - epoch).total_seconds())\",\n \"def total_seconds(self):\\n return 0\",\n \"def time_to_sec(duration):\\r\\n duration, unit = val_to_type_unit(duration)\\r\\n if unit in ['h', 'hr', 'hrs', 'hours', 'hour']:\\r\\n duration *= 60 * 60\\r\\n elif unit in ['m', 'min', 'mins', 'minutes', 'minute']:\\r\\n duration *= 60\\r\\n elif unit in [None, 's', 'sec', 'secs', 'seconds', 'second']:\\r\\n pass\\r\\n else:\\r\\n raise ValueError('Unrecognized time unit: %s' % unit)\\r\\n\\r\\n return duration\",\n \"def seconds_calc(delta):\\n return (delta.hours * 3600) + (delta.minutes * 60) + delta.seconds\",\n \"def time_calculator(seconds):\\n seconds = int(seconds)\\n days = seconds // 86400\\n hours = seconds % 86400 // 3600\\n minutes = seconds % 86400 % 3600 // 60\\n seconds = seconds % 86400 % 3600 % 60\\n time_list = [days, hours, minutes, seconds] # Created a list that stores these variables in order\\n return time_list\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78827816","0.7511598","0.74796194","0.73971415","0.7275454","0.7262169","0.718104","0.71555495","0.7036447","0.69965965","0.6980901","0.6879055","0.6844431","0.6838192","0.6817343","0.67910403","0.67888385","0.6770099","0.67639846","0.67639846","0.67117536","0.6669582","0.6667897","0.66359055","0.6626798","0.66068095","0.6584932","0.65769017","0.6571989","0.65678054","0.65436876","0.6539787","0.6521976","0.64970416","0.64860666","0.6481699","0.646516","0.64440006","0.64234275","0.63929164","0.63791203","0.6361192","0.6352644","0.63493294","0.63359576","0.6303653","0.62998635","0.6299437","0.6268969","0.6251691","0.625104","0.6247059","0.62223047","0.6205099","0.61887914","0.6188417","0.61738664","0.6172743","0.61660427","0.6155546","0.61523527","0.613869","0.61099225","0.6106957","0.60951155","0.6090831","0.60861695","0.6085775","0.60821885","0.60680014","0.6061436","0.6054678","0.6052032","0.6033719","0.6032996","0.6014317","0.6008535","0.6003864","0.6002843","0.5976622","0.59675854","0.5967132","0.5965642","0.59586436","0.5957098","0.5956984","0.5950654","0.59488755","0.5943253","0.59355885","0.59312725","0.5897838","0.5895243","0.58921266","0.58828187","0.58656734","0.5856097","0.585122","0.5845675"],"string":"[\n \"0.78827816\",\n \"0.7511598\",\n \"0.74796194\",\n \"0.73971415\",\n \"0.7275454\",\n \"0.7262169\",\n \"0.718104\",\n \"0.71555495\",\n \"0.7036447\",\n \"0.69965965\",\n \"0.6980901\",\n \"0.6879055\",\n \"0.6844431\",\n \"0.6838192\",\n \"0.6817343\",\n \"0.67910403\",\n \"0.67888385\",\n \"0.6770099\",\n \"0.67639846\",\n \"0.67639846\",\n \"0.67117536\",\n \"0.6669582\",\n \"0.6667897\",\n \"0.66359055\",\n \"0.6626798\",\n \"0.66068095\",\n \"0.6584932\",\n \"0.65769017\",\n \"0.6571989\",\n \"0.65678054\",\n \"0.65436876\",\n \"0.6539787\",\n \"0.6521976\",\n \"0.64970416\",\n \"0.64860666\",\n \"0.6481699\",\n \"0.646516\",\n \"0.64440006\",\n \"0.64234275\",\n \"0.63929164\",\n \"0.63791203\",\n \"0.6361192\",\n \"0.6352644\",\n \"0.63493294\",\n \"0.63359576\",\n \"0.6303653\",\n \"0.62998635\",\n \"0.6299437\",\n \"0.6268969\",\n \"0.6251691\",\n \"0.625104\",\n \"0.6247059\",\n \"0.62223047\",\n \"0.6205099\",\n \"0.61887914\",\n \"0.6188417\",\n \"0.61738664\",\n \"0.6172743\",\n \"0.61660427\",\n \"0.6155546\",\n \"0.61523527\",\n \"0.613869\",\n \"0.61099225\",\n \"0.6106957\",\n \"0.60951155\",\n \"0.6090831\",\n \"0.60861695\",\n \"0.6085775\",\n \"0.60821885\",\n \"0.60680014\",\n \"0.6061436\",\n \"0.6054678\",\n \"0.6052032\",\n \"0.6033719\",\n \"0.6032996\",\n \"0.6014317\",\n \"0.6008535\",\n \"0.6003864\",\n \"0.6002843\",\n \"0.5976622\",\n \"0.59675854\",\n \"0.5967132\",\n \"0.5965642\",\n \"0.59586436\",\n \"0.5957098\",\n \"0.5956984\",\n \"0.5950654\",\n \"0.59488755\",\n \"0.5943253\",\n \"0.59355885\",\n \"0.59312725\",\n \"0.5897838\",\n \"0.5895243\",\n \"0.58921266\",\n \"0.58828187\",\n \"0.58656734\",\n \"0.5856097\",\n \"0.585122\",\n \"0.5845675\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70772296"},"document_rank":{"kind":"string","value":"9"}}},{"rowIdx":18599,"cells":{"query":{"kind":"string","value":"Check the give word is palindrome."},"document":{"kind":"string","value":"def isPalindrome(word):\n\n input_str = IGNORE_NON_ALPHA_CHARACTER.sub(\"\", str(word)).casefold()\n return input_str == input_str[::-1]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def palindrome(word):\n reverse = word[::-1]\n return word == reverse","def is_palindrome(word):\n if word == word[::-1]:\n return True\n else:\n return False","def is_palindrome(word: str) -> bool:\n\n # Todo\n return False","def check_palindrome():","def string_palidrome(word):\n if word == string_reverse(word):\n return True\n else:\n return False","def is_palindrome(word):\n word = word.replace(\" \", \"\")\n new_word = word.lower()\n\n return new_word == new_word[::-1]","def is_palindrome(word):\n if len(word)>2 and not is_palindrome(middle(word)):\n return False\n else:\n return first(word) == last(word)","def is_palindrome(word):\n word = validator(word)\n\n if word == \"\":\n return True\n\n elif word[0] == word[-1]:\n return is_palindrome(word[1:-1])\n\n return False","def check_palindrome(s):\n return s[::-1] == s","def is_palindrome(word):\n if first(word) != last(word):\n print 'not a palindrome'\n return False\n else:\n return is_palindrome(middle(word))","def is_palindrome(word):\n\t# The degenerate case is 1 letter or none. We consider these palindromes\n\tif len(word) <= 1:\n\t\treturn True\n\n\t# For something to be a palindrome, the first and last letters much match\n\t# and the string between them must also be a palindrome\n\tif first(word) == last(word) and is_palindrome(middle(word)):\n\t\treturn True\n\telse:\n\t\treturn False","def is_palindrome2(word):\n\n word = word.lower()\n\n if not word.isalnum():\n word = ''.join(character for character in word if character.isalnum())\n\n if word == \"\":\n return True\n\n while len(word) > 1:\n\n if word[0] == word[-1]:\n word = word[1:-1]\n\n else:\n return False\n\n return True","def is_palindrome2(some_string):\n return reverse_string(some_string) == some_string","def is_palindrome(string):\n return","def is_palindrome_v1(s):\n return reverse(s) == s","def is_palindrome(sentence: str) -> bool:\n\n words = extract_words(sentence)\n middle = floor(len(words)/2)\n\n for index in range(middle):\n if words[index].lower() != words[len(words)-index-1].lower():\n return False\n\n return True","def is_palindrome(string):\n return string[::-1] == string","def checkPalindrome(self, s: str) -> str:\n # return s[:len(s) // 2] == s[(len(s) + 1) // 2::-1]\n return s == s[::-1]","def isPalindrome(self, s: str) -> bool:\n s = s.translate(str.maketrans('','',string.punctuation)) # drop punctuation\n s = \"\".join(s.split()) # drop spaces\n s = s.lower() # casefold more agressive (ASCII vs UNICODE)\n\n return s == s[::-1]","def isPalindrome(s):\r\n return isPal(toChars(s))","def is_palindrome(s):\n return s == s[::-1]","def is_palindrome3(word):\n\n i = 0\n j = -1\n\n word = word.lower()\n\n if not word.isalnum():\n word = ''.join(character for character in word if character.isalnum())\n\n if word == \"\":\n return True\n\n while len(word) > 1:\n\n if word[i] == word[j]:\n\n i += 1\n j += 1\n\n else:\n return False\n\n return True","def is_palindromic(phrase):\n\n val = str(phrase).lower().replace(\" \", \"\")\n if val == val[::-1]: # Reverse order\n return True\n else:\n return False","def is_palindrome(phrase):\n # remove spaces\n phrase = phrase.replace(' ', '').lower()\n\n # reverse phrase\n ans = ''\n for index in range(len(phrase)-1, -1, -1):\n ans += phrase[index]\n\n return True if ans == phrase else False","def check_palindrome(word):\r\n char_count = {} #char count hash\r\n for char in word:\r\n if char in char_count:\r\n char_count[char] += 1\r\n else:\r\n char_count[char] = 1\r\n odd_count = 0 #counting number of odd nos encountered\r\n for count in char_count.values():\r\n if count % 2 != 0:\r\n odd_count += 1\r\n len_word = len(word)\r\n if len_word % 2 == 0:\r\n if odd_count >= 1:\r\n return False\r\n else:\r\n if odd_count > 1:\r\n return False\r\n return True","def is_palindrome(string):\n if string == string[::-1]:\n return True\n return False","def palindrome(string: str) -> Bool:\n string_lower = string.lower()\n string_clean =","def is_palindrome(string):\n string = string.upper()\n if reverse(string) == string:\n #use function reverse() to check if the reverse of the string is same as the original string\n return True\n else:\n return False","def is_palindrome(s):\n rev_str = \"\"\n for let in range(1, len(s) + 1):\n rev_str += s[-let]\n return rev_str == s","def palindrome(string):\r\n if len(string) <= 1:\r\n return True\r\n else:","def check_palindrome(inp_string):\n if len(inp_string) <= 2:\n return False\n elif inp_string == inp_string[::-1]:\n return True\n else:\n return False","def isPalindrome(string):\n for i in range(len(string)//2):\n if string[i] != string[(i*-1)-1]:\n return False\n return True","def is_palindrome_v2(s):\n n = len(s)\n\n return s[:n/2] == reverse(s[n-n/2:])","def check_palindrome():\n # Your code goes here...","def is_palindrome(s):\n s_copy = s.replace(\" \", \"\")\n n = len(s_copy)\n for i in range(n // 2):\n left = s_copy[i]\n right = s_copy[n - 1 - i]\n if left.upper() != right.upper():\n return False\n return True","def is_palindrome(s):\n i, end = 0, len(s) // 2\n while i < end:\n if s[i] != s[len(s) - i - 1]:\n return False\n i += 1\n return True","def is_palindrome(string):\n k, mid = len(string), len(string) // 2\n # checking even palindromes\n if k % 2 == 0:\n return string[:mid] == get_reverse_complement(string[mid:])\n # checking odd palindromes\n else:\n return string[:mid] == get_reverse_complement(string[mid + 1:])","def is_palindrome(n):\n return(n == reverse(n))","def check_palindrome(string):\n palindrome = ''.join(string).lower()\n if palindrome == palindrome[::-1]:\n return True\n else:\n return False","def is_palindrome(n):\n ns = str(n)\n for i in range(0, len(ns) // 2):\n if ns[i] != ns[len(ns) - 1 - i]: return False\n return True","def palindrome(x):\n pass","def palindrome_check(num):\n num= str(num)\n len_num= len(num)\n for i in range(len_num/2):\n if num[i] == num[len_num-i-1]:\n ans= True\n else:\n ans= False\n break\n return ans","def check_is_palindrome(mer1, mer2):\n return mer1.find(mer2[::-1]) == 0","def isPalindrome(self, s: str) -> bool:\n left, right = 0, len(s) - 1\n while left < right:\n while left < right and not s[left].isalnum(): # 注意while loop的嵌套\n left += 1\n while left < right and not s[right].isalnum():\n right -= 1\n if s[left].lower() != s[right].lower():\n return False\n left += 1\n right -= 1\n return True","def is_palindrome(the_string: str) -> bool:\n s = the_string.lower()\n # left pointer\n i = 0\n # right pointer\n j = len(s)-1\n # before the left pointer and right pointer meets\n while i < j:\n # if meet white space, the left pointer will move forward without doing anything.\n while i < j and s[i] == \" \":\n i += 1\n # if meet white space, the right pointer will move forward without doing anything.\n while i < j and s[j] == \" \":\n j -= 1\n # test if the char at left pointer equals with char at the right pointer , if yes,\n # left and right pointer move forward to test next pair of chars\n if s[i] == s[j]:\n i += 1\n j -= 1\n # if not, the string is not a palindrome, return False\n else:\n return False\n else:\n return True","def is_palindrome(number):\r\n str_input = str(number)\r\n return str_input == reversed(str_input)","def is_palindrome(string):\r\n r_string = string[::-1]\r\n cnt = 0\r\n while cnt < len(string):\r\n if string[cnt] == r_string[cnt]:\r\n cnt += 1\r\n continue\r\n else:\r\n return False\r\n #cnt += 1\r\n return True","def isPalindrome(self, s: str) -> bool:\n if not s:\n return True\n # process the string\n s_processed = \"\"\n for i in s:\n if i.isalnum():\n s_processed += i.lower()\n # Check if palindrome\n return s_processed == s_processed[::-1] # String[::-1], O(n)","def is_palindrome_v3(s):\n i = 0\n j = len(s)-1\n\n while i < j and s[i] == s[j]:\n i = i + 1\n j = j -1\n\n return j <= i","def isPalindrome(n):\n str_n = str(n)\n return list(str_n) == list(reversed(str_n))","def part3(string):\n palindrome = True\n for i in range(0, int(len(string)/2) + 1):\n if(string[i] != string[int(len(string))-i-1]):\n palindrome = False\n print(palindrome)","def is_palindrome(str):\n n = len(str)\n for i in range(n//2): # loop to middle of string str\n if str[i] != str[-1-i]:\n return False # find a character doesn't match with its mirror-positioned character\n return True # reach this, then str is palindrome","def is_palindrome(num):\n\treversed_num = str(num)[::-1]\n\tif reversed_num == str(num): return True\n\telse: return False","def validPalindrome(self, s: str) -> bool:\n n = len(s)\n i = 0\n j = n - 1\n while i < j:\n if s[i] == s[j]:\n i += 1\n j -= 1\n else:\n # error, for -1, start > end. Indexing is like range\n # return s[i:j] == s[i:j:-1] or s[i+1:j+1] == s[i+1:j+1:-1]\n return self.is_palindrome(s[i:j]) or self.is_palindrome(s[i+1:j+1])\n\n return True","def is_palindrome(sub):\n for i in range(len(sub)):\n if sub[i] != sub[len(sub) - i - 1]:\n return False\n return True","def part3():\n Input = raw_input('please enter a string:')\n for i in range(len(Input)):\n if Input[i] != Input[len(Input)-i-1]:\n print('It is not a palidrome')\n break\n else:\n i = i + 1","def is_palendrome(my_string):\n characters = []\n for char in my_string:\n characters.append(char)\n characters.reverse()\n reversed_string = \"\".join(characters)\n if my_string == reversed_string:\n return True\n else:\n return False","def is_palindrome(text):\n\n # Property of a palindrome:\n # There be a maximum of only one letter that sums to an odd number\n \n char_count = {}\n # edge cases\n # Consider empty text as palindrome\n \n for char in text:\n if char in char_count:\n char_count[char] += 1\n else:\n char_count[char] = 1\n \n odd_count = 0\n for count in char_count.values():\n if count % 2 == 1:\n odd_count += 1\n if odd_count > 1:\n return False\n \n return True","def isPalindrome(x):\n # Write the functionality:\n\n if x == str(x)[::-1]:\n return True\n elif x==121:\n return True\n else:\n return False","def is_palindrome(s):\n\n def to_chars(s):\n s = s.lower()\n letters = ''\n for char in s:\n if char in 'abcdefghijklmnopqrstuvwxyz':\n letters += char\n return letters\n\n def is_pal(s):\n if len(s) <= 1:\n return True\n else:\n return s[0] == s[-1] and is_pal(s[1:-1])\n\n return is_pal(to_chars(s))","def is_palindrome(some_string):\n\n if some_string == \"\":\n return True\n elif len(some_string) == 1:\n return True\n elif some_string[0] != some_string[-1]:\n return False\n else:\n return is_palindrome(some_string[1:-1])","def is_palindrome(num_in):\n if str(num_in) == str(num_in)[::-1]:\n return True\n\n return False","def is_palindrome(n):\n num = list(str(n))\n h1 = num[:int(len(num)/2)] # first half of palindrome\n if len(num) % 2 == 0:\n h2 = num[int(len(num)/2):] # second half of palindrome\n else:\n h2 = num[int(len(num)/2) + 1:]\n return h1 == list(reversed(h2))","def is_palindrome(element):\n if int(element) < 0:\n return False\n if element == element[::-1]:\n return True\n else:\n return False","def is_palindrome(text):\n\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\n # return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def _is_palindrome(input_str, start, end):\n if start >= end:\n return True\n if input_str[start] != input_str[end]:\n return False\n else:\n return _is_palindrome(input_str, start + 1, end - 1)","def is_palindrome_ingoring_case_and_non_letter_chars(text):","def isPalindromes(s):\n\n def toChar(s):\n s= s.lower()\n letters=''\n for c in s:\n if c in \"abcdefgh\":\n letters= letters+c\n return letters\n\n def isPal(s):\n if len(s) <=1:\n return True\n else:\n return s[0]==s[-1] and isPal(s[1:-1])\n return isPal(toChar(s))","def is_palindrome(x):\n strx = str(x)\n return strx == strx[::-1]\n # chars = [c for c in x] if not is_number(x) else digits(x)\n # for i in range(len(chars) // 2):\n # if chars[i] != chars[len(chars) - i - 1]:\n # return False\n # return True","def isPalindromic(n: int):\n return str(n) == str(n)[::-1]","def is_palindromic(n: int) -> bool:\n str_n = str(n)\n if str_n == str_n[::-1]:\n return True\n return False","def is_palindrome(num):\n str_num = str(num)\n\n if len(str_num) == 1:\n return True\n elif len(str_num) == 2:\n return str_num[0] == str_num[1]\n\n if str_num[0] == str_num[len(str_num)-1]:\n return is_palindrome(str_num[1:len(str_num)-1])\n else:\n return False","def ispalindrome(string):\n if isinstance(string, (str, int, float)):\n string = str(string).replace(\" \", \"\").lower()\n if len(string) in [0,1]:\n return True\n half_index = len(string) // 2\n first = string[:half_index]\n second = string[-half_index:]\n if first == second[::-1]:\n return True\n else:\n return False\n else:\n print(\"ERROR: ispalindrome received invalid input.\\nREASON: input\",\n \"must be convertible to string format.\")","def is_palindrome(text):\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\n # change this to call your implementation to verify it passes all tests\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\n #return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def is_palindrome(text):\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\n # change this to call your implementation to verify it passes all tests\n assert isinstance(text, str)\n # return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def is_palindrome(text):\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\n # change this to call your implementation to verify it passes all tests\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\n # return is_palindrome_iterative(text)\n return is_palindrome_recursive(text)","def has_palindrome(i, start, length):\r\n s = str(i)[start:start+length]\r\n return s[::-1] == s","def palCheck(input_string):\n\n # ADD NECESSARY LINES OF CODE SO THAT ALL UNITTESTS PASS\n\n d = Deque()\n for char in input_string:\n d.addFront(char)\n\n while d.size() > 1:\n firstChar = d.removeRear()\n lastChar = d.removeFront()\n if firstChar != lastChar:\n print(\"No, '\" + input_string + \"', is not a palindrom\")\n return False\n\n print(\"Yes, '\" + input_string + \"', is a palindrom!!\")\n return True","def isPalindrome(S):\n if len(S) == 0:\n return True\n \n if S[0] != S[-1]:\n return False\n \n return isPalindrome(S[1:len(S) - 1])","def is_anagram_of_palindrome(word):\n # palindrome has either exactly 2 of each letter in the word\n # or two of each letter revolving around one in the middle\n # An anagram rescrambles the letters\n chars = []\n\n # loop over the word\n # append chars to the list\n # if we see the char in list again, remove it.\n # if there is only one char or no chars in list\n # return True\n # else, return false\n\n for char in word:\n if char in chars:\n chars.remove(char)\n else:\n chars.append(char)\n if len(chars) >= 2:\n return False\n else:\n return True","def is_pallendrome(self):\n pass","def is_palindrome(s):\n if isinstance(s, str):\n if s == s[::-1]:\n return True\n else:\n return False\n if isinstance(s, int):\n if str(s) == str(s)[::-1]:\n return True\n else:\n return False\n else:\n raise AssertionError(\"Please enter str\")","def is_palindrome(n):\n d = digits(n)\n r = int(\"\".join([str(i) for i in d]))\n return n == r","def palindrome_itertive(a):\n # TODO make this less crappy\n start = 0 \n end = len(a) - 1\n while start != end:\n # print(end)\n # print('start: ', start, ' a: ', a[start])\n # print('end: ', end, ' a: ', a[end])\n if not a[start] == a[end]:\n return False\n else:\n start += 1\n end -= 1\n return True","def check_palindrome(string):\n queue = Deque() # creating object of Deque class\n\n for ch in string:\n queue.insert_rear(ch) # adds all the characters from back\n\n is_equal = True\n\n while queue.size() > 1 and is_equal:\n first = queue.remove_front() # removes the characters from the front of the queue\n last = queue.remove_rear() # removes the characters from the rear of the queue\n if first != last:\n is_equal = False\n\n return is_equal","def is_permutation_palindrome(str):\n for s in permutations(str): # loop through all permutations of str\n if is_palindrome(s):\n return True # successfully find a palindrome permutation\n return False # reach this, then no possible permutation is palindrome","def is_palindrome(string):\n\n # Base case: If the string is one character long or fewer, it's a palindrome.\n if len(string) <= 1:\n return True\n \n # Base case: If the first and last characters in the string don't match, it isn't a palindrome.\n if string[0] != string[-1]:\n return False\n \n # At this point, the first and last character in the string are identical.\n # Recursive case: Check if the string remaining after removing the first and last character\n # is a palindrome. If so, this string is a palindrome too.\n return is_palindrome(string[1:-1])","def is_palindrome(n):\n v = []\n while n > 0:\n v.append(n % 10)\n n //= 10\n for i in range(len(v)//2):\n if v[i] != v[len(v)-i-1]:\n return False\n return True","def isLychrel(Number):\r\n Number+=reverse(Number)\r\n n=0\r\n while n<50:\r\n if isPalindrome(Number):\r\n return False\r\n else:\r\n Number+=reverse(Number)\r\n n+=1\r\n return True","def yes_straw_warts():\n check50.run(\"python3 palindrome.py\"\n ).stdout(\"Word? \", regex=False\n ).stdin(\"straw warts\", prompt=False\n ).stdout(\"YES\", regex=False\n ).exit()","def palindrome_integer(string):\n integers = string.split(\" \")\n for integer in integers:\n reverse = str(int)[::-1]\n '''Check if palindrome not then return False'''\n if integer != reverse:\n return False\n return True","def isPalendrome(number):\n\t\n\tnum = str(number)\n\ti \t= 0\n\tj \t= len(num) - 1\n\tmid = len(num) // 2\n\n\t#print(mid)\n\t\n\t# While i and j are not in the middle\n\twhile( i != mid):\n\t\t#print(i,j,sep=\"\\t\")\n\t\t#print(num[i],num[j], sep=\"\\t\")\n\t\tif(num[i] != num[j]):\n\t\t\treturn(False)\n\t\telse:\n\t\t\ti = i + 1\n\t\t\tj = j - 1\n\n\treturn(True)","def is_palindrome(x):\n \n # Assume negative number is not a palindromic number.\n if x < 0:\n return False\n\n ten_base = 1\n \n # Determine num size with a base of 10\n while x / ten_base >= 10:\n ten_base *= 10\n\n while x > 0:\n left_num, right_num = x / ten_base, x % 10\n if left_num != right_num:\n return False\n \n # Update and prep for next iteration.\n x = (x % ten_base) / 10\n ten_base /= 100\n\n return True","def is_reverse(first_word, second_word):\n if len(first_word) != len(second_word):\n return \"Not the same as the first word !\"\n\n fwd_count = 0\n bckwd_count = len(second_word) - 1\n\n while bckwd_count > 0:\n if first_word[fwd_count] == second_word[bckwd_count]:\n fwd_count += 1\n bckwd_count -= 1\n else:\n return \"Not the same as the first word !2\"\n return first_word + \" is the same as \" + second_word + \" reversed !\"","def is_palindrome(n):\n x, y = n, 0\n f = lambda: 10 * y + x % 10\n while x > 0:\n x, y = x // 10, f()\n return y == n","def isPal(x):\n temp = x\n temp.reverse()\n if temp == x:\n print('true')\n return True\n else:\n print('false')\n return False","def check_pal(s):\n counts = df(int)\n len_without_spaces = 0\n # Count all nonspaces\n for c in s:\n if c != ' ':\n counts[c.lower()] += 1\n len_without_spaces += 1\n # Now find out how many chars occur an odd number of times\n odd_chars = 0\n for c in counts:\n if counts[c] % 2 != 0:\n odd_chars += 1\n # If string length is even there must be no odd counts\n if len_without_spaces % 2 == 0 and odd_chars == 0:\n return True\n # If string is odd there must be exactly one odd count\n if len_without_spaces % 2 != 0 and odd_chars == 1:\n return True\n # Else, it's not a palindrome\n return False","def is_palindrome(num):\n digitList = int2list(num)\n \n i = 0\n while i <= round(len(digitList)/2):\n if digitList[i] != digitList[-(i+1)]:\n return False\n i += 1\n return True","def is_palindromic(lst):\n return all( lst[i] == lst[-(i+1)] for i in range(len(lst)) )","def is_palindrome(n):\n # store locally\n temp = n\n rev = 0\n while n > 0:\n # get digit one by one\n digit = n % 10\n # find reverse number\n rev = rev * 10 + digit\n # divide the number\n n = n // 10\n return temp == rev"],"string":"[\n \"def palindrome(word):\\n reverse = word[::-1]\\n return word == reverse\",\n \"def is_palindrome(word):\\n if word == word[::-1]:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(word: str) -> bool:\\n\\n # Todo\\n return False\",\n \"def check_palindrome():\",\n \"def string_palidrome(word):\\n if word == string_reverse(word):\\n return True\\n else:\\n return False\",\n \"def is_palindrome(word):\\n word = word.replace(\\\" \\\", \\\"\\\")\\n new_word = word.lower()\\n\\n return new_word == new_word[::-1]\",\n \"def is_palindrome(word):\\n if len(word)>2 and not is_palindrome(middle(word)):\\n return False\\n else:\\n return first(word) == last(word)\",\n \"def is_palindrome(word):\\n word = validator(word)\\n\\n if word == \\\"\\\":\\n return True\\n\\n elif word[0] == word[-1]:\\n return is_palindrome(word[1:-1])\\n\\n return False\",\n \"def check_palindrome(s):\\n return s[::-1] == s\",\n \"def is_palindrome(word):\\n if first(word) != last(word):\\n print 'not a palindrome'\\n return False\\n else:\\n return is_palindrome(middle(word))\",\n \"def is_palindrome(word):\\n\\t# The degenerate case is 1 letter or none. We consider these palindromes\\n\\tif len(word) <= 1:\\n\\t\\treturn True\\n\\n\\t# For something to be a palindrome, the first and last letters much match\\n\\t# and the string between them must also be a palindrome\\n\\tif first(word) == last(word) and is_palindrome(middle(word)):\\n\\t\\treturn True\\n\\telse:\\n\\t\\treturn False\",\n \"def is_palindrome2(word):\\n\\n word = word.lower()\\n\\n if not word.isalnum():\\n word = ''.join(character for character in word if character.isalnum())\\n\\n if word == \\\"\\\":\\n return True\\n\\n while len(word) > 1:\\n\\n if word[0] == word[-1]:\\n word = word[1:-1]\\n\\n else:\\n return False\\n\\n return True\",\n \"def is_palindrome2(some_string):\\n return reverse_string(some_string) == some_string\",\n \"def is_palindrome(string):\\n return\",\n \"def is_palindrome_v1(s):\\n return reverse(s) == s\",\n \"def is_palindrome(sentence: str) -> bool:\\n\\n words = extract_words(sentence)\\n middle = floor(len(words)/2)\\n\\n for index in range(middle):\\n if words[index].lower() != words[len(words)-index-1].lower():\\n return False\\n\\n return True\",\n \"def is_palindrome(string):\\n return string[::-1] == string\",\n \"def checkPalindrome(self, s: str) -> str:\\n # return s[:len(s) // 2] == s[(len(s) + 1) // 2::-1]\\n return s == s[::-1]\",\n \"def isPalindrome(self, s: str) -> bool:\\n s = s.translate(str.maketrans('','',string.punctuation)) # drop punctuation\\n s = \\\"\\\".join(s.split()) # drop spaces\\n s = s.lower() # casefold more agressive (ASCII vs UNICODE)\\n\\n return s == s[::-1]\",\n \"def isPalindrome(s):\\r\\n return isPal(toChars(s))\",\n \"def is_palindrome(s):\\n return s == s[::-1]\",\n \"def is_palindrome3(word):\\n\\n i = 0\\n j = -1\\n\\n word = word.lower()\\n\\n if not word.isalnum():\\n word = ''.join(character for character in word if character.isalnum())\\n\\n if word == \\\"\\\":\\n return True\\n\\n while len(word) > 1:\\n\\n if word[i] == word[j]:\\n\\n i += 1\\n j += 1\\n\\n else:\\n return False\\n\\n return True\",\n \"def is_palindromic(phrase):\\n\\n val = str(phrase).lower().replace(\\\" \\\", \\\"\\\")\\n if val == val[::-1]: # Reverse order\\n return True\\n else:\\n return False\",\n \"def is_palindrome(phrase):\\n # remove spaces\\n phrase = phrase.replace(' ', '').lower()\\n\\n # reverse phrase\\n ans = ''\\n for index in range(len(phrase)-1, -1, -1):\\n ans += phrase[index]\\n\\n return True if ans == phrase else False\",\n \"def check_palindrome(word):\\r\\n char_count = {} #char count hash\\r\\n for char in word:\\r\\n if char in char_count:\\r\\n char_count[char] += 1\\r\\n else:\\r\\n char_count[char] = 1\\r\\n odd_count = 0 #counting number of odd nos encountered\\r\\n for count in char_count.values():\\r\\n if count % 2 != 0:\\r\\n odd_count += 1\\r\\n len_word = len(word)\\r\\n if len_word % 2 == 0:\\r\\n if odd_count >= 1:\\r\\n return False\\r\\n else:\\r\\n if odd_count > 1:\\r\\n return False\\r\\n return True\",\n \"def is_palindrome(string):\\n if string == string[::-1]:\\n return True\\n return False\",\n \"def palindrome(string: str) -> Bool:\\n string_lower = string.lower()\\n string_clean =\",\n \"def is_palindrome(string):\\n string = string.upper()\\n if reverse(string) == string:\\n #use function reverse() to check if the reverse of the string is same as the original string\\n return True\\n else:\\n return False\",\n \"def is_palindrome(s):\\n rev_str = \\\"\\\"\\n for let in range(1, len(s) + 1):\\n rev_str += s[-let]\\n return rev_str == s\",\n \"def palindrome(string):\\r\\n if len(string) <= 1:\\r\\n return True\\r\\n else:\",\n \"def check_palindrome(inp_string):\\n if len(inp_string) <= 2:\\n return False\\n elif inp_string == inp_string[::-1]:\\n return True\\n else:\\n return False\",\n \"def isPalindrome(string):\\n for i in range(len(string)//2):\\n if string[i] != string[(i*-1)-1]:\\n return False\\n return True\",\n \"def is_palindrome_v2(s):\\n n = len(s)\\n\\n return s[:n/2] == reverse(s[n-n/2:])\",\n \"def check_palindrome():\\n # Your code goes here...\",\n \"def is_palindrome(s):\\n s_copy = s.replace(\\\" \\\", \\\"\\\")\\n n = len(s_copy)\\n for i in range(n // 2):\\n left = s_copy[i]\\n right = s_copy[n - 1 - i]\\n if left.upper() != right.upper():\\n return False\\n return True\",\n \"def is_palindrome(s):\\n i, end = 0, len(s) // 2\\n while i < end:\\n if s[i] != s[len(s) - i - 1]:\\n return False\\n i += 1\\n return True\",\n \"def is_palindrome(string):\\n k, mid = len(string), len(string) // 2\\n # checking even palindromes\\n if k % 2 == 0:\\n return string[:mid] == get_reverse_complement(string[mid:])\\n # checking odd palindromes\\n else:\\n return string[:mid] == get_reverse_complement(string[mid + 1:])\",\n \"def is_palindrome(n):\\n return(n == reverse(n))\",\n \"def check_palindrome(string):\\n palindrome = ''.join(string).lower()\\n if palindrome == palindrome[::-1]:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(n):\\n ns = str(n)\\n for i in range(0, len(ns) // 2):\\n if ns[i] != ns[len(ns) - 1 - i]: return False\\n return True\",\n \"def palindrome(x):\\n pass\",\n \"def palindrome_check(num):\\n num= str(num)\\n len_num= len(num)\\n for i in range(len_num/2):\\n if num[i] == num[len_num-i-1]:\\n ans= True\\n else:\\n ans= False\\n break\\n return ans\",\n \"def check_is_palindrome(mer1, mer2):\\n return mer1.find(mer2[::-1]) == 0\",\n \"def isPalindrome(self, s: str) -> bool:\\n left, right = 0, len(s) - 1\\n while left < right:\\n while left < right and not s[left].isalnum(): # 注意while loop的嵌套\\n left += 1\\n while left < right and not s[right].isalnum():\\n right -= 1\\n if s[left].lower() != s[right].lower():\\n return False\\n left += 1\\n right -= 1\\n return True\",\n \"def is_palindrome(the_string: str) -> bool:\\n s = the_string.lower()\\n # left pointer\\n i = 0\\n # right pointer\\n j = len(s)-1\\n # before the left pointer and right pointer meets\\n while i < j:\\n # if meet white space, the left pointer will move forward without doing anything.\\n while i < j and s[i] == \\\" \\\":\\n i += 1\\n # if meet white space, the right pointer will move forward without doing anything.\\n while i < j and s[j] == \\\" \\\":\\n j -= 1\\n # test if the char at left pointer equals with char at the right pointer , if yes,\\n # left and right pointer move forward to test next pair of chars\\n if s[i] == s[j]:\\n i += 1\\n j -= 1\\n # if not, the string is not a palindrome, return False\\n else:\\n return False\\n else:\\n return True\",\n \"def is_palindrome(number):\\r\\n str_input = str(number)\\r\\n return str_input == reversed(str_input)\",\n \"def is_palindrome(string):\\r\\n r_string = string[::-1]\\r\\n cnt = 0\\r\\n while cnt < len(string):\\r\\n if string[cnt] == r_string[cnt]:\\r\\n cnt += 1\\r\\n continue\\r\\n else:\\r\\n return False\\r\\n #cnt += 1\\r\\n return True\",\n \"def isPalindrome(self, s: str) -> bool:\\n if not s:\\n return True\\n # process the string\\n s_processed = \\\"\\\"\\n for i in s:\\n if i.isalnum():\\n s_processed += i.lower()\\n # Check if palindrome\\n return s_processed == s_processed[::-1] # String[::-1], O(n)\",\n \"def is_palindrome_v3(s):\\n i = 0\\n j = len(s)-1\\n\\n while i < j and s[i] == s[j]:\\n i = i + 1\\n j = j -1\\n\\n return j <= i\",\n \"def isPalindrome(n):\\n str_n = str(n)\\n return list(str_n) == list(reversed(str_n))\",\n \"def part3(string):\\n palindrome = True\\n for i in range(0, int(len(string)/2) + 1):\\n if(string[i] != string[int(len(string))-i-1]):\\n palindrome = False\\n print(palindrome)\",\n \"def is_palindrome(str):\\n n = len(str)\\n for i in range(n//2): # loop to middle of string str\\n if str[i] != str[-1-i]:\\n return False # find a character doesn't match with its mirror-positioned character\\n return True # reach this, then str is palindrome\",\n \"def is_palindrome(num):\\n\\treversed_num = str(num)[::-1]\\n\\tif reversed_num == str(num): return True\\n\\telse: return False\",\n \"def validPalindrome(self, s: str) -> bool:\\n n = len(s)\\n i = 0\\n j = n - 1\\n while i < j:\\n if s[i] == s[j]:\\n i += 1\\n j -= 1\\n else:\\n # error, for -1, start > end. Indexing is like range\\n # return s[i:j] == s[i:j:-1] or s[i+1:j+1] == s[i+1:j+1:-1]\\n return self.is_palindrome(s[i:j]) or self.is_palindrome(s[i+1:j+1])\\n\\n return True\",\n \"def is_palindrome(sub):\\n for i in range(len(sub)):\\n if sub[i] != sub[len(sub) - i - 1]:\\n return False\\n return True\",\n \"def part3():\\n Input = raw_input('please enter a string:')\\n for i in range(len(Input)):\\n if Input[i] != Input[len(Input)-i-1]:\\n print('It is not a palidrome')\\n break\\n else:\\n i = i + 1\",\n \"def is_palendrome(my_string):\\n characters = []\\n for char in my_string:\\n characters.append(char)\\n characters.reverse()\\n reversed_string = \\\"\\\".join(characters)\\n if my_string == reversed_string:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(text):\\n\\n # Property of a palindrome:\\n # There be a maximum of only one letter that sums to an odd number\\n \\n char_count = {}\\n # edge cases\\n # Consider empty text as palindrome\\n \\n for char in text:\\n if char in char_count:\\n char_count[char] += 1\\n else:\\n char_count[char] = 1\\n \\n odd_count = 0\\n for count in char_count.values():\\n if count % 2 == 1:\\n odd_count += 1\\n if odd_count > 1:\\n return False\\n \\n return True\",\n \"def isPalindrome(x):\\n # Write the functionality:\\n\\n if x == str(x)[::-1]:\\n return True\\n elif x==121:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(s):\\n\\n def to_chars(s):\\n s = s.lower()\\n letters = ''\\n for char in s:\\n if char in 'abcdefghijklmnopqrstuvwxyz':\\n letters += char\\n return letters\\n\\n def is_pal(s):\\n if len(s) <= 1:\\n return True\\n else:\\n return s[0] == s[-1] and is_pal(s[1:-1])\\n\\n return is_pal(to_chars(s))\",\n \"def is_palindrome(some_string):\\n\\n if some_string == \\\"\\\":\\n return True\\n elif len(some_string) == 1:\\n return True\\n elif some_string[0] != some_string[-1]:\\n return False\\n else:\\n return is_palindrome(some_string[1:-1])\",\n \"def is_palindrome(num_in):\\n if str(num_in) == str(num_in)[::-1]:\\n return True\\n\\n return False\",\n \"def is_palindrome(n):\\n num = list(str(n))\\n h1 = num[:int(len(num)/2)] # first half of palindrome\\n if len(num) % 2 == 0:\\n h2 = num[int(len(num)/2):] # second half of palindrome\\n else:\\n h2 = num[int(len(num)/2) + 1:]\\n return h1 == list(reversed(h2))\",\n \"def is_palindrome(element):\\n if int(element) < 0:\\n return False\\n if element == element[::-1]:\\n return True\\n else:\\n return False\",\n \"def is_palindrome(text):\\n\\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\\n # return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def _is_palindrome(input_str, start, end):\\n if start >= end:\\n return True\\n if input_str[start] != input_str[end]:\\n return False\\n else:\\n return _is_palindrome(input_str, start + 1, end - 1)\",\n \"def is_palindrome_ingoring_case_and_non_letter_chars(text):\",\n \"def isPalindromes(s):\\n\\n def toChar(s):\\n s= s.lower()\\n letters=''\\n for c in s:\\n if c in \\\"abcdefgh\\\":\\n letters= letters+c\\n return letters\\n\\n def isPal(s):\\n if len(s) <=1:\\n return True\\n else:\\n return s[0]==s[-1] and isPal(s[1:-1])\\n return isPal(toChar(s))\",\n \"def is_palindrome(x):\\n strx = str(x)\\n return strx == strx[::-1]\\n # chars = [c for c in x] if not is_number(x) else digits(x)\\n # for i in range(len(chars) // 2):\\n # if chars[i] != chars[len(chars) - i - 1]:\\n # return False\\n # return True\",\n \"def isPalindromic(n: int):\\n return str(n) == str(n)[::-1]\",\n \"def is_palindromic(n: int) -> bool:\\n str_n = str(n)\\n if str_n == str_n[::-1]:\\n return True\\n return False\",\n \"def is_palindrome(num):\\n str_num = str(num)\\n\\n if len(str_num) == 1:\\n return True\\n elif len(str_num) == 2:\\n return str_num[0] == str_num[1]\\n\\n if str_num[0] == str_num[len(str_num)-1]:\\n return is_palindrome(str_num[1:len(str_num)-1])\\n else:\\n return False\",\n \"def ispalindrome(string):\\n if isinstance(string, (str, int, float)):\\n string = str(string).replace(\\\" \\\", \\\"\\\").lower()\\n if len(string) in [0,1]:\\n return True\\n half_index = len(string) // 2\\n first = string[:half_index]\\n second = string[-half_index:]\\n if first == second[::-1]:\\n return True\\n else:\\n return False\\n else:\\n print(\\\"ERROR: ispalindrome received invalid input.\\\\nREASON: input\\\",\\n \\\"must be convertible to string format.\\\")\",\n \"def is_palindrome(text):\\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\\n # change this to call your implementation to verify it passes all tests\\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\\n #return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def is_palindrome(text):\\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\\n # change this to call your implementation to verify it passes all tests\\n assert isinstance(text, str)\\n # return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def is_palindrome(text):\\n # implement is_palindrome_iterative and is_palindrome_recursive below, then\\n # change this to call your implementation to verify it passes all tests\\n assert isinstance(text, str), 'input is not a string: {}'.format(text)\\n # return is_palindrome_iterative(text)\\n return is_palindrome_recursive(text)\",\n \"def has_palindrome(i, start, length):\\r\\n s = str(i)[start:start+length]\\r\\n return s[::-1] == s\",\n \"def palCheck(input_string):\\n\\n # ADD NECESSARY LINES OF CODE SO THAT ALL UNITTESTS PASS\\n\\n d = Deque()\\n for char in input_string:\\n d.addFront(char)\\n\\n while d.size() > 1:\\n firstChar = d.removeRear()\\n lastChar = d.removeFront()\\n if firstChar != lastChar:\\n print(\\\"No, '\\\" + input_string + \\\"', is not a palindrom\\\")\\n return False\\n\\n print(\\\"Yes, '\\\" + input_string + \\\"', is a palindrom!!\\\")\\n return True\",\n \"def isPalindrome(S):\\n if len(S) == 0:\\n return True\\n \\n if S[0] != S[-1]:\\n return False\\n \\n return isPalindrome(S[1:len(S) - 1])\",\n \"def is_anagram_of_palindrome(word):\\n # palindrome has either exactly 2 of each letter in the word\\n # or two of each letter revolving around one in the middle\\n # An anagram rescrambles the letters\\n chars = []\\n\\n # loop over the word\\n # append chars to the list\\n # if we see the char in list again, remove it.\\n # if there is only one char or no chars in list\\n # return True\\n # else, return false\\n\\n for char in word:\\n if char in chars:\\n chars.remove(char)\\n else:\\n chars.append(char)\\n if len(chars) >= 2:\\n return False\\n else:\\n return True\",\n \"def is_pallendrome(self):\\n pass\",\n \"def is_palindrome(s):\\n if isinstance(s, str):\\n if s == s[::-1]:\\n return True\\n else:\\n return False\\n if isinstance(s, int):\\n if str(s) == str(s)[::-1]:\\n return True\\n else:\\n return False\\n else:\\n raise AssertionError(\\\"Please enter str\\\")\",\n \"def is_palindrome(n):\\n d = digits(n)\\n r = int(\\\"\\\".join([str(i) for i in d]))\\n return n == r\",\n \"def palindrome_itertive(a):\\n # TODO make this less crappy\\n start = 0 \\n end = len(a) - 1\\n while start != end:\\n # print(end)\\n # print('start: ', start, ' a: ', a[start])\\n # print('end: ', end, ' a: ', a[end])\\n if not a[start] == a[end]:\\n return False\\n else:\\n start += 1\\n end -= 1\\n return True\",\n \"def check_palindrome(string):\\n queue = Deque() # creating object of Deque class\\n\\n for ch in string:\\n queue.insert_rear(ch) # adds all the characters from back\\n\\n is_equal = True\\n\\n while queue.size() > 1 and is_equal:\\n first = queue.remove_front() # removes the characters from the front of the queue\\n last = queue.remove_rear() # removes the characters from the rear of the queue\\n if first != last:\\n is_equal = False\\n\\n return is_equal\",\n \"def is_permutation_palindrome(str):\\n for s in permutations(str): # loop through all permutations of str\\n if is_palindrome(s):\\n return True # successfully find a palindrome permutation\\n return False # reach this, then no possible permutation is palindrome\",\n \"def is_palindrome(string):\\n\\n # Base case: If the string is one character long or fewer, it's a palindrome.\\n if len(string) <= 1:\\n return True\\n \\n # Base case: If the first and last characters in the string don't match, it isn't a palindrome.\\n if string[0] != string[-1]:\\n return False\\n \\n # At this point, the first and last character in the string are identical.\\n # Recursive case: Check if the string remaining after removing the first and last character\\n # is a palindrome. If so, this string is a palindrome too.\\n return is_palindrome(string[1:-1])\",\n \"def is_palindrome(n):\\n v = []\\n while n > 0:\\n v.append(n % 10)\\n n //= 10\\n for i in range(len(v)//2):\\n if v[i] != v[len(v)-i-1]:\\n return False\\n return True\",\n \"def isLychrel(Number):\\r\\n Number+=reverse(Number)\\r\\n n=0\\r\\n while n<50:\\r\\n if isPalindrome(Number):\\r\\n return False\\r\\n else:\\r\\n Number+=reverse(Number)\\r\\n n+=1\\r\\n return True\",\n \"def yes_straw_warts():\\n check50.run(\\\"python3 palindrome.py\\\"\\n ).stdout(\\\"Word? \\\", regex=False\\n ).stdin(\\\"straw warts\\\", prompt=False\\n ).stdout(\\\"YES\\\", regex=False\\n ).exit()\",\n \"def palindrome_integer(string):\\n integers = string.split(\\\" \\\")\\n for integer in integers:\\n reverse = str(int)[::-1]\\n '''Check if palindrome not then return False'''\\n if integer != reverse:\\n return False\\n return True\",\n \"def isPalendrome(number):\\n\\t\\n\\tnum = str(number)\\n\\ti \\t= 0\\n\\tj \\t= len(num) - 1\\n\\tmid = len(num) // 2\\n\\n\\t#print(mid)\\n\\t\\n\\t# While i and j are not in the middle\\n\\twhile( i != mid):\\n\\t\\t#print(i,j,sep=\\\"\\\\t\\\")\\n\\t\\t#print(num[i],num[j], sep=\\\"\\\\t\\\")\\n\\t\\tif(num[i] != num[j]):\\n\\t\\t\\treturn(False)\\n\\t\\telse:\\n\\t\\t\\ti = i + 1\\n\\t\\t\\tj = j - 1\\n\\n\\treturn(True)\",\n \"def is_palindrome(x):\\n \\n # Assume negative number is not a palindromic number.\\n if x < 0:\\n return False\\n\\n ten_base = 1\\n \\n # Determine num size with a base of 10\\n while x / ten_base >= 10:\\n ten_base *= 10\\n\\n while x > 0:\\n left_num, right_num = x / ten_base, x % 10\\n if left_num != right_num:\\n return False\\n \\n # Update and prep for next iteration.\\n x = (x % ten_base) / 10\\n ten_base /= 100\\n\\n return True\",\n \"def is_reverse(first_word, second_word):\\n if len(first_word) != len(second_word):\\n return \\\"Not the same as the first word !\\\"\\n\\n fwd_count = 0\\n bckwd_count = len(second_word) - 1\\n\\n while bckwd_count > 0:\\n if first_word[fwd_count] == second_word[bckwd_count]:\\n fwd_count += 1\\n bckwd_count -= 1\\n else:\\n return \\\"Not the same as the first word !2\\\"\\n return first_word + \\\" is the same as \\\" + second_word + \\\" reversed !\\\"\",\n \"def is_palindrome(n):\\n x, y = n, 0\\n f = lambda: 10 * y + x % 10\\n while x > 0:\\n x, y = x // 10, f()\\n return y == n\",\n \"def isPal(x):\\n temp = x\\n temp.reverse()\\n if temp == x:\\n print('true')\\n return True\\n else:\\n print('false')\\n return False\",\n \"def check_pal(s):\\n counts = df(int)\\n len_without_spaces = 0\\n # Count all nonspaces\\n for c in s:\\n if c != ' ':\\n counts[c.lower()] += 1\\n len_without_spaces += 1\\n # Now find out how many chars occur an odd number of times\\n odd_chars = 0\\n for c in counts:\\n if counts[c] % 2 != 0:\\n odd_chars += 1\\n # If string length is even there must be no odd counts\\n if len_without_spaces % 2 == 0 and odd_chars == 0:\\n return True\\n # If string is odd there must be exactly one odd count\\n if len_without_spaces % 2 != 0 and odd_chars == 1:\\n return True\\n # Else, it's not a palindrome\\n return False\",\n \"def is_palindrome(num):\\n digitList = int2list(num)\\n \\n i = 0\\n while i <= round(len(digitList)/2):\\n if digitList[i] != digitList[-(i+1)]:\\n return False\\n i += 1\\n return True\",\n \"def is_palindromic(lst):\\n return all( lst[i] == lst[-(i+1)] for i in range(len(lst)) )\",\n \"def is_palindrome(n):\\n # store locally\\n temp = n\\n rev = 0\\n while n > 0:\\n # get digit one by one\\n digit = n % 10\\n # find reverse number\\n rev = rev * 10 + digit\\n # divide the number\\n n = n // 10\\n return temp == rev\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.89213616","0.8837968","0.8779761","0.87497747","0.86763763","0.85616016","0.83406484","0.83270764","0.8197752","0.8196361","0.8171091","0.8113323","0.8112018","0.8089886","0.80283785","0.80139244","0.79979086","0.79918855","0.7983047","0.79630023","0.7962088","0.79260516","0.7919617","0.7910766","0.7904438","0.7897089","0.7816498","0.77861905","0.7775366","0.77471733","0.7743996","0.7743689","0.7713213","0.76876426","0.7654457","0.7622403","0.76205593","0.76174587","0.7616346","0.76153404","0.75994307","0.755615","0.75552875","0.7548566","0.7495248","0.74918604","0.7471405","0.74692374","0.7458909","0.74517757","0.7414082","0.7395823","0.73782164","0.73759305","0.7363835","0.73462915","0.73201305","0.7304114","0.7297893","0.72924596","0.7273993","0.72738343","0.72710353","0.7254795","0.7249055","0.72138745","0.7207627","0.71988165","0.7196672","0.7174193","0.71586895","0.7152417","0.7120408","0.70941037","0.709129","0.7090735","0.7041644","0.7031551","0.7012534","0.6975849","0.69635195","0.6923249","0.6918805","0.6889581","0.6874806","0.6869342","0.6840204","0.683686","0.6816019","0.67890203","0.6784559","0.6780556","0.67696553","0.67402786","0.673948","0.67359835","0.6731101","0.6727875","0.6723713","0.67175496"],"string":"[\n \"0.89213616\",\n \"0.8837968\",\n \"0.8779761\",\n \"0.87497747\",\n \"0.86763763\",\n \"0.85616016\",\n \"0.83406484\",\n \"0.83270764\",\n \"0.8197752\",\n \"0.8196361\",\n \"0.8171091\",\n \"0.8113323\",\n \"0.8112018\",\n \"0.8089886\",\n \"0.80283785\",\n \"0.80139244\",\n \"0.79979086\",\n \"0.79918855\",\n \"0.7983047\",\n \"0.79630023\",\n \"0.7962088\",\n \"0.79260516\",\n \"0.7919617\",\n \"0.7910766\",\n \"0.7904438\",\n \"0.7897089\",\n \"0.7816498\",\n \"0.77861905\",\n \"0.7775366\",\n \"0.77471733\",\n \"0.7743996\",\n \"0.7743689\",\n \"0.7713213\",\n \"0.76876426\",\n \"0.7654457\",\n \"0.7622403\",\n \"0.76205593\",\n \"0.76174587\",\n \"0.7616346\",\n \"0.76153404\",\n \"0.75994307\",\n \"0.755615\",\n \"0.75552875\",\n \"0.7548566\",\n \"0.7495248\",\n \"0.74918604\",\n \"0.7471405\",\n \"0.74692374\",\n \"0.7458909\",\n \"0.74517757\",\n \"0.7414082\",\n \"0.7395823\",\n \"0.73782164\",\n \"0.73759305\",\n \"0.7363835\",\n \"0.73462915\",\n \"0.73201305\",\n \"0.7304114\",\n \"0.7297893\",\n \"0.72924596\",\n \"0.7273993\",\n \"0.72738343\",\n \"0.72710353\",\n \"0.7254795\",\n \"0.7249055\",\n \"0.72138745\",\n \"0.7207627\",\n \"0.71988165\",\n \"0.7196672\",\n \"0.7174193\",\n \"0.71586895\",\n \"0.7152417\",\n \"0.7120408\",\n \"0.70941037\",\n \"0.709129\",\n \"0.7090735\",\n \"0.7041644\",\n \"0.7031551\",\n \"0.7012534\",\n \"0.6975849\",\n \"0.69635195\",\n \"0.6923249\",\n \"0.6918805\",\n \"0.6889581\",\n \"0.6874806\",\n \"0.6869342\",\n \"0.6840204\",\n \"0.683686\",\n \"0.6816019\",\n \"0.67890203\",\n \"0.6784559\",\n \"0.6780556\",\n \"0.67696553\",\n \"0.67402786\",\n \"0.673948\",\n \"0.67359835\",\n \"0.6731101\",\n \"0.6727875\",\n \"0.6723713\",\n \"0.67175496\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8555572"},"document_rank":{"kind":"string","value":"6"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":185,"numItemsPerPage":100,"numTotalItems":95772,"offset":18500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjI1OTYzMiwianRpIjoiNTM5NTc1NWItMTdjNy00MmEyLWJmZTYtMzIzNWZkODg3YWEyIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyNjMyMzIsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.nkReSahgtmLbljV7NTQbQyc1yAHBuHd24rBGNLeWm-2uey0cknLX973-wFqBSCDymR-HUIscaBRStvszZLHrBA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Return requested conference (by websafeConferenceKey). | def getConference(self, request):
# Get Conference object from request; bail if not found
conf = _getEntityByWebsafeKey(request.websafeConferenceKey,
'Conference')
prof = conf.key.parent().get()
# Return ConferenceForm
return self._copyConfer... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getConference(self, request):\n # get Conference object from request; bail if not found\n conf = ndb.Key(urlsafe=request.websafeConferenceKey).get()\n if not conf:\n raise endpoints.NotFoundException(\n 'No conference found with key: %s' % request.websafeConferenceKey)\n prof = co... | [
"0.78688127",
"0.7338922",
"0.6852561",
"0.66271746",
"0.6565396",
"0.6170011",
"0.59663105",
"0.59223247",
"0.58999187",
"0.58343786",
"0.57726926",
"0.57710207",
"0.56881297",
"0.5676969",
"0.56550586",
"0.55980533",
"0.5535486",
"0.5489521",
"0.5484447",
"0.5409856",
"0.53... | 0.73678344 | 1 |
Get list of conferences matching one or more of the given topics. | def getConferencesByTopicSearch(self, request):
conferences = self._getConferencesByTopicSearch(request)
# Need to fetch organiser displayName from profiles
# Get all keys and use get_multi for speed
organisers = [
(ndb.Key(Profile, conf.organizerUserId)) for conf in conferen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getConferencesByTopicSearch(self, request):\n # Generate list of filters from the topic arguments\n filters = [Conference.topics == topic for topic in request.topics]\n if not filters:\n raise endpoints.BadRequestException(\n 'At least one topic must be specified... | [
"0.80247796",
"0.6207768",
"0.6082327",
"0.60714567",
"0.60658276",
"0.5967323",
"0.5963362",
"0.59466356",
"0.59359396",
"0.59351933",
"0.5891676",
"0.5859516",
"0.5841561",
"0.5830634",
"0.57371825",
"0.5714454",
"0.57058376",
"0.56997335",
"0.5605298",
"0.54814893",
"0.542... | 0.67396516 | 1 |
Return conferences created by user. | def getConferencesCreated(self, request):
# Make sure user is authenticated
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = user.email()
# Create ancestor query for all key matches for this use... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_conferences_created(self, request):\n # make sure user is authed\n user = endpoints.get_current_user()\n if not user:\n raise endpoints.UnauthorizedException('Authorization required')\n user_id = self.auth.get_user_id(user)\n\n # create ancestor query for all k... | [
"0.7426375",
"0.7422197",
"0.7139423",
"0.6520319",
"0.6444673",
"0.6380157",
"0.6170725",
"0.6110125",
"0.6106259",
"0.58488816",
"0.58413064",
"0.5712337",
"0.56976974",
"0.56128216",
"0.55150616",
"0.5484686",
"0.54634756",
"0.54023856",
"0.539838",
"0.5397218",
"0.5395133... | 0.736354 | 2 |
Get list of conferences for which the user has registered. | def getConferencesToAttend(self, request):
prof = self._getProfileFromUser() # get user Profile
conf_keys = [
ndb.Key(urlsafe=wsck) for wsck in prof.conferenceKeysToAttend
]
conferences = ndb.get_multi(conf_keys)
# Get organizers
organisers = [
ndb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conferences(self):\r\n return conferences.Conferences(self)",
"def get_conferences():\n conferences = []\n for confId in range(1, 8):\n c = requests.get(CONFERENCES_URL.format(confId)).json()\n conf_list = c.get('conferences')\n if conf_list is None or len(conf_list) == 0:\n... | [
"0.8020829",
"0.74782985",
"0.691444",
"0.6898903",
"0.6854732",
"0.6811999",
"0.6588752",
"0.6450787",
"0.6318484",
"0.61732143",
"0.5985208",
"0.5971348",
"0.5906679",
"0.5899746",
"0.5890189",
"0.5807684",
"0.57925874",
"0.5785232",
"0.57073826",
"0.57045716",
"0.56997824"... | 0.6654006 | 6 |
Register user for selected conference. | def registerForConference(self, request):
return self._conferenceRegistration(request) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_for_conference(self, request):\n return self.conference_registration(request)",
"def register_user():\n pass",
"def conference_registration(self, request, reg=True):\n prof = self.profile_service.get_profile_from_user() # get user Profile\n\n # check if conf exists given w... | [
"0.7278912",
"0.6624827",
"0.6584575",
"0.65791625",
"0.6362521",
"0.61771995",
"0.61010563",
"0.6078329",
"0.6028847",
"0.60168606",
"0.6004366",
"0.60029817",
"0.59709775",
"0.5970334",
"0.5965763",
"0.59528124",
"0.5946669",
"0.5870501",
"0.5858669",
"0.58469427",
"0.58424... | 0.70775634 | 1 |
Unregister user for selected conference. | def unregisterFromConference(self, request):
return self._conferenceRegistration(request, reg=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unregister_from_conference(self, request):\n return self.conference_registration(request, reg=False)",
"async def unregister(self):\n\t\tif self.group != None:\n\t\t\tif self.group.in_game:\n\t\t\t\tfor team in self.group.game.teams:\n\t\t\t\t\tif self in team:\n\t\t\t\t\t\tself.group.game.teams.remov... | [
"0.7598682",
"0.6543255",
"0.6435641",
"0.63821507",
"0.63548124",
"0.63164395",
"0.61379206",
"0.6102971",
"0.60985017",
"0.6050816",
"0.59991133",
"0.597415",
"0.59388",
"0.5870086",
"0.5869279",
"0.58567876",
"0.5786231",
"0.57730377",
"0.5772766",
"0.5762881",
"0.5759947"... | 0.7392909 | 1 |
Update conference with provided fields and return updated info. | def updateConference(self, request):
return self._updateConferenceObject(request) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def updateConference(self, request):\n return self._updateConferenceObject(request)",
"def update_conference(self, request):\n return self.conference_service.update_conference_object(request)",
"def _createConferenceObject(self, request):\n # Preload necessary data items\n user = endpoi... | [
"0.758331",
"0.74960595",
"0.56102973",
"0.5389422",
"0.53092176",
"0.5298347",
"0.52690583",
"0.5262601",
"0.5237994",
"0.52372456",
"0.5190294",
"0.51562655",
"0.5151782",
"0.5141383",
"0.5108595",
"0.51068795",
"0.5103918",
"0.5081992",
"0.50674534",
"0.5066077",
"0.503872... | 0.7384815 | 2 |
Copy relevant fields from Speaker to SpeakerForm. | def _copySpeakerToForm(self, speaker):
sf = SpeakerForm()
for field in sf.all_fields():
if hasattr(speaker, field.name):
setattr(sf, field.name, getattr(speaker, field.name))
elif field.name == "websafeKey":
setattr(sf, field.name, speaker.key.urls... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copyform(form, settings):\r\n for name, value in form.iteritems():\r\n setattr(settings, name, value)\r\n settings.commit()",
"def _copySessionToForm(self, session):\n sf = SessionForm()\n for field in sf.all_fields():\n if hasattr(session, field.name):\n ... | [
"0.5991479",
"0.5911988",
"0.58958936",
"0.5770801",
"0.57492906",
"0.5703371",
"0.56609124",
"0.5593124",
"0.5583714",
"0.5578275",
"0.55456966",
"0.5397008",
"0.53902537",
"0.5387579",
"0.5369967",
"0.53496546",
"0.5334173",
"0.5330454",
"0.530139",
"0.5282616",
"0.51898223... | 0.8053849 | 0 |
Create a speaker, returning SpeakerForm/request. | def _createSpeakerObject(self, request):
# Preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = user.email()
if not request.name:
raise endpoints.BadRequestE... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create(self, validated_data):\n return Speaker.objects.create(**validated_data)",
"def _copySpeakerToForm(self, speaker):\n sf = SpeakerForm()\n for field in sf.all_fields():\n if hasattr(speaker, field.name):\n setattr(sf, field.name, getattr(speaker, field.nam... | [
"0.7516256",
"0.6617961",
"0.6517369",
"0.60076547",
"0.58922905",
"0.58491045",
"0.5713825",
"0.57095647",
"0.5580512",
"0.5575898",
"0.5537071",
"0.54411596",
"0.54135704",
"0.54083437",
"0.53903764",
"0.5356573",
"0.53268087",
"0.5320126",
"0.5311113",
"0.53081363",
"0.529... | 0.7869294 | 0 |
Check if the specified speaker is speaking at multiple sessions in the specified conference, and create memcache entry if so. | def _updateFeaturedSpeaker(websafeSpeakerKey, websafeConferenceKey):
# Validate the websafe key arguments. Exception is raised if either
# call fails.
speaker = _getEntityByWebsafeKey(websafeSpeakerKey, 'Speaker')
confKey = _raiseIfWebsafeKeyNotValid(websafeConferenceKey,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getSessionsBySpeaker(self, request):\n # Ensure that the speaker key is valid and that the speaker exists\n speaker = _getEntityByWebsafeKey(request.websafeSpeakerKey, 'Speaker')\n # Return all of the speaker's sessions\n return ndb.get_multi(speaker.sessions)",
"def _getConferen... | [
"0.5446472",
"0.51810056",
"0.5084203",
"0.5033835",
"0.49242762",
"0.48869962",
"0.4859192",
"0.48236132",
"0.4786593",
"0.47050533",
"0.46819773",
"0.46688312",
"0.46350497",
"0.45954737",
"0.45568752",
"0.4550118",
"0.45501018",
"0.4542919",
"0.45304805",
"0.452583",
"0.45... | 0.56610495 | 0 |
Return the current featured speaker message from memcache. | def getFeaturedSpeaker(self, request):
message = memcache.get(MEMCACHE_FEATURED_SPEAKER_KEY) or ""
return StringMessage(data=message) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_featured_speaker(self, request):\n return StringMessage(\n data=memcache.get(MEMCACHE_FEATURED_SPEAKER_KEY) or \"\")",
"def _updateFeaturedSpeaker(websafeSpeakerKey, websafeConferenceKey):\n # Validate the websafe key arguments. Exception is raised if either\n # call fails... | [
"0.7784476",
"0.58692867",
"0.58229965",
"0.5695719",
"0.56409705",
"0.5568219",
"0.54920876",
"0.54669094",
"0.5427401",
"0.5424601",
"0.5384481",
"0.5369317",
"0.5333994",
"0.5280963",
"0.5277826",
"0.5231841",
"0.5128428",
"0.50919986",
"0.50889385",
"0.50869083",
"0.50726... | 0.7579103 | 1 |
Return requested speaker (by websafeSpeakerKey). | def getSpeaker(self, request):
# Get Speaker object from request; bail if not found
speaker = _getEntityByWebsafeKey(request.websafeSpeakerKey,
'Speaker')
# Return SpeakerForm
return self._copySpeakerToForm(speaker) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_speaker(self):\n return self._speaker",
"def get_speaker(self):\n if self._speaker == None:\n self._speaker = self.get_best_speaker()\n return self._speaker",
"def getFeaturedSpeaker(self, request):\n message = memcache.get(MEMCACHE_FEATURED_SPEAKER_KEY) or \"\"\n... | [
"0.7760669",
"0.7620859",
"0.67306876",
"0.64560616",
"0.59528273",
"0.5847423",
"0.5846053",
"0.5844817",
"0.5813224",
"0.56656796",
"0.55755717",
"0.55755717",
"0.556649",
"0.54978883",
"0.5484221",
"0.5462861",
"0.5461837",
"0.54197496",
"0.5388767",
"0.53737676",
"0.53307... | 0.7046036 | 2 |
Get list of all speakers in the system. | def getSpeakers(self, request):
speakers = Speaker.query().order(Speaker.name).fetch()
# Return individual SpeakerForm object per Speaker
return SpeakerForms(
items=[self._copySpeakerToForm(speaker) for speaker in speakers]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_speakers(self, request):\n return self.speaker_service.get_speakers()",
"def speakers(self):\n return self._speakers",
"def list_speaker(request, template=\"core/list_speaker.html\"):\n speakers = Speaker.objects.all()\n response = { 'speakers': speakers, 'show_all_info': False }\n ... | [
"0.84661525",
"0.83643174",
"0.7133389",
"0.661066",
"0.6588881",
"0.64534485",
"0.6366197",
"0.63607436",
"0.63581705",
"0.6350021",
"0.60030264",
"0.59532773",
"0.59065694",
"0.5903705",
"0.58986825",
"0.589644",
"0.58819747",
"0.5877112",
"0.5862711",
"0.58491725",
"0.5789... | 0.6570793 | 5 |
Add a session to the user's wishlist, returning a boolean. | def _addSessionToWishlist(self, request):
# Preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Verify that the session actually exists
session = _getEntityByWebsafeKey(request... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_session_to_wishlist(self, request):\n return self.wishlist_service.add_session_to_wishlist(\n request.websafeSessionKey, endpoints.get_current_user())",
"def add_session_to_wishlist(self, websafe_session_key, user):\n wl_key = self.get_wishlist_key(user)\n\n wishlist = wl_... | [
"0.8124176",
"0.7818929",
"0.7583546",
"0.6178471",
"0.6127408",
"0.5941033",
"0.5855412",
"0.581283",
"0.57922465",
"0.57513714",
"0.57402354",
"0.56839013",
"0.5678189",
"0.56736964",
"0.5617717",
"0.5528249",
"0.5518363",
"0.5493492",
"0.54671645",
"0.54640555",
"0.5460476... | 0.83459866 | 0 |
Create a session, returning SessionForm/request. | def _createSessionObject(self, request):
# Preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = user.email()
# Get the conference entity
conf = _getEntityByWebsa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_session(\n self,\n environ: str,\n session_request_to_use: typing.Optional[SessionRequest] = None,\n ) -> Session:\n self.poll_sessions() # make sure there is an up to date picture of Sessions before proceeding\n self.check_session_can_start(session_request_to_use)... | [
"0.7286548",
"0.7119273",
"0.7006085",
"0.69913393",
"0.69766575",
"0.69718444",
"0.69162",
"0.68441635",
"0.682855",
"0.6828313",
"0.6804701",
"0.6702148",
"0.66709447",
"0.66621274",
"0.66581345",
"0.66455007",
"0.664158",
"0.66088223",
"0.6524842",
"0.64846593",
"0.6434405... | 0.7054775 | 2 |
Copy relevant fields from Session to SessionForm. | def _copySessionToForm(self, session):
sf = SessionForm()
for field in sf.all_fields():
if hasattr(session, field.name):
# Convert date field to date string
if field.name == 'date':
setattr(sf, field.name, str(getattr(session, field.name)))... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def form_valid(self, form):\n label = form.cleaned_data[\"label\"]\n\n if \"objects\" not in self.request.session:\n self.request.session[\"objects\"] = OrderedDict()\n if \"forms\" not in self.request.session:\n self.request.session[\"forms\"] = OrderedDict()\n\n ... | [
"0.6098217",
"0.6088412",
"0.6072761",
"0.60642654",
"0.6026982",
"0.59829164",
"0.5759055",
"0.5618044",
"0.561432",
"0.55417347",
"0.5487526",
"0.54755",
"0.544686",
"0.5294741",
"0.52286774",
"0.52258146",
"0.5166349",
"0.5164965",
"0.51523036",
"0.51498306",
"0.5126769",
... | 0.85230947 | 0 |
Retrieve all sessions associated with a conference. | def _getConferenceSessions(self, request):
# Ensure that websafeConferenceKey is a valid conference key
confKey = _raiseIfWebsafeKeyNotValid(request.websafeConferenceKey,
'Conference')
# Retrieve all sessions that have a matching conference key
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_conference_sessions(self, request):\n return self.session_service.get_conference_sessions(\n request.websafeConferenceKey)",
"def get_sessions_by_type(self, request):\n return self.session_service.get_conference_sessions_by_type(\n request.websafeConferenceKey, request... | [
"0.8155603",
"0.72048026",
"0.7024871",
"0.7000029",
"0.69593084",
"0.6693818",
"0.66356134",
"0.66315794",
"0.65811247",
"0.6544365",
"0.64583755",
"0.643887",
"0.64130956",
"0.63868886",
"0.63120866",
"0.62812674",
"0.6271837",
"0.6205866",
"0.6112134",
"0.6100491",
"0.6069... | 0.800364 | 1 |
Retrieve all sessions associated with a conference, by type. | def _getConferenceSessionsByType(self, request):
# Ensure that websafeConferenceKey is a valid conference key
confKey = _raiseIfWebsafeKeyNotValid(request.websafeConferenceKey,
'Conference')
# Retrieve all sessions that have a matching conference key,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sessions_by_type(self, request):\n return self.session_service.get_conference_sessions_by_type(\n request.websafeConferenceKey, request.sessionType)",
"def get_sessions_by_type_and_filters(self, request):\n return self.session_service.get_sessions_by_type_and_filters(\n ... | [
"0.839267",
"0.76810974",
"0.74179673",
"0.72810936",
"0.7257645",
"0.6629272",
"0.6575053",
"0.6291302",
"0.61481535",
"0.60031515",
"0.59337205",
"0.5886013",
"0.5719723",
"0.57138413",
"0.57089686",
"0.5639327",
"0.5602851",
"0.5507092",
"0.5500614",
"0.54822844",
"0.54750... | 0.83530176 | 1 |
Retrieve all sessions matching one or more given highlights. | def _getSessionsByHighlightSearch(self, request):
# Generate list of filters from the highlight arguments
filters = [Session.highlights == hl for hl in request.highlights]
if not filters:
raise endpoints.BadRequestException(
'At least one highlight must be specified'
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getSessionsByHighlightSearch(self, request):\n sessions = self._getSessionsByHighlightSearch(request)\n # Return individual SessionForm object per Session\n return SessionForms(\n items=[self._copySessionToForm(session) for session in sessions]\n )",
"def get(self, requ... | [
"0.64075655",
"0.51973224",
"0.5143006",
"0.5126674",
"0.49887824",
"0.49578515",
"0.49377143",
"0.48807254",
"0.48346448",
"0.47855932",
"0.47821313",
"0.47626352",
"0.47079334",
"0.4697971",
"0.46542692",
"0.46254164",
"0.46242422",
"0.4623829",
"0.46137628",
"0.45952874",
... | 0.80607086 | 0 |
Retrieve all sessions given by a particular speaker. | def _getSessionsBySpeaker(self, request):
# Ensure that the speaker key is valid and that the speaker exists
speaker = _getEntityByWebsafeKey(request.websafeSpeakerKey, 'Speaker')
# Return all of the speaker's sessions
return ndb.get_multi(speaker.sessions) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_speaker_sessions(self, request):\n return self.session_service.get_speaker_sessions(\n request.websafeSpeakerKey)",
"def getSessionsBySpeaker(self, request):\n sessions = self._getSessionsBySpeaker(request)\n # Return individual SessionForm object per Session\n retu... | [
"0.78710306",
"0.7094641",
"0.67780095",
"0.67494416",
"0.67155963",
"0.6615327",
"0.64614207",
"0.6425885",
"0.6333383",
"0.6315707",
"0.6194976",
"0.61806315",
"0.6179548",
"0.61346084",
"0.61164176",
"0.60324794",
"0.60129184",
"0.5877937",
"0.58242875",
"0.5822374",
"0.58... | 0.8179627 | 0 |
Demonstrates my solution to the doubleinequality query problem. | def _getSessionsDoubleInequalityDemo(self, request):
# Convert request.maxStartTime from string to Time object
try:
maxStartTime = datetime.strptime(
request.maxStartTime, '%H:%M').time()
except:
raise endpoints.BadRequestException(
"Invali... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dq_subquery_filter(self):\n # import ipdb; ipdb.set_trace()\n len1 = len(list(DQ('(b.id, b.name) Book{b.id in [\"(Book.id)\"]} b').dicts()))\n len2 = len(list(DQ(\"(Book.id)\").dicts()))\n self.assertEqual(len1, len2)",
"def query3() :",
"def test_multiple_iterations_work_p... | [
"0.62650895",
"0.61998206",
"0.6114937",
"0.60249525",
"0.6004869",
"0.5909111",
"0.58909786",
"0.5840364",
"0.58223784",
"0.57433224",
"0.57068557",
"0.5687743",
"0.5659272",
"0.5618641",
"0.5598052",
"0.55531514",
"0.55465287",
"0.5494882",
"0.54774994",
"0.54695725",
"0.54... | 0.0 | -1 |
Retrieve all sessions in the user's wishlist. | def _getSessionsInWishlist(self):
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
profile = self._getProfileFromUser()
# Fetch the entities and return them
return ndb.get_multi(profile.sessionWishlist) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wishlist_sessions(self, user):\n wishlist_key = self.get_wishlist_key(user)\n session_keys = [ndb.Key(urlsafe=wsck) for wsck in\n wishlist_key.get().sessionKeys]\n sessions = ndb.get_multi(session_keys)\n return sessions",
"def get_sessions_in_wishlist(self,... | [
"0.851661",
"0.79517555",
"0.7718727",
"0.7539904",
"0.74082303",
"0.69785184",
"0.6908265",
"0.6861531",
"0.6479205",
"0.6430566",
"0.61952454",
"0.6161288",
"0.61303025",
"0.6128384",
"0.6097037",
"0.6083551",
"0.60752475",
"0.5979322",
"0.59384423",
"0.5929593",
"0.5898026... | 0.8228693 | 1 |
Removes a session from the user's wishlist, returning a boolean. | def _removeSessionFromWishlist(self, request):
# Preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
profile = self._getProfileFromUser()
# Get actual session key from websafe ke... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_session_from_wishlist(self, request):\n return self.wishlist_service.remove_session_from_wishlist(\n request.websafeSessionKey, endpoints.get_current_user())",
"def removeSessionFromWishlist(self, request):\n return self._removeSessionFromWishlist(request)",
"def remove_sess... | [
"0.81915665",
"0.76984537",
"0.76317555",
"0.6835183",
"0.6607075",
"0.6478658",
"0.6209266",
"0.61053085",
"0.6085781",
"0.6084388",
"0.6060252",
"0.5823839",
"0.57571155",
"0.57422817",
"0.57323414",
"0.57050776",
"0.5699716",
"0.56986994",
"0.5697193",
"0.5694112",
"0.5676... | 0.8256191 | 0 |
Get list of sessions associated with a conference. | def getConferenceSessions(self, request):
sessions = self._getConferenceSessions(request)
# Return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_conference_sessions(self, request):\n return self.session_service.get_conference_sessions(\n request.websafeConferenceKey)",
"def _getConferenceSessions(self, request):\n # Ensure that websafeConferenceKey is a valid conference key\n confKey = _raiseIfWebsafeKeyNotValid(re... | [
"0.81798553",
"0.80553985",
"0.7398432",
"0.70670617",
"0.69621783",
"0.6918743",
"0.6725701",
"0.67132723",
"0.6662291",
"0.6658466",
"0.6619637",
"0.66083187",
"0.66049355",
"0.6575915",
"0.64666444",
"0.6356312",
"0.62984157",
"0.6294037",
"0.628976",
"0.62862515",
"0.6215... | 0.7115856 | 3 |
Get list of sessions associated with a conference (by type). | def getConferenceSessionsByType(self, request):
sessions = self._getConferenceSessionsByType(request)
# Return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sessions_by_type(self, request):\n return self.session_service.get_conference_sessions_by_type(\n request.websafeConferenceKey, request.sessionType)",
"def _getConferenceSessionsByType(self, request):\n # Ensure that websafeConferenceKey is a valid conference key\n confKey... | [
"0.84242547",
"0.8401543",
"0.7662441",
"0.7524862",
"0.74432117",
"0.6784176",
"0.6719207",
"0.6384199",
"0.6341055",
"0.62116015",
"0.6180524",
"0.61600953",
"0.61047417",
"0.5998957",
"0.59904486",
"0.59777117",
"0.5891309",
"0.58634335",
"0.5858132",
"0.58035517",
"0.5781... | 0.7440639 | 5 |
Get list of sessions matching one or more of the given highlights. | def getSessionsByHighlightSearch(self, request):
sessions = self._getSessionsByHighlightSearch(request)
# Return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getSessionsByHighlightSearch(self, request):\n # Generate list of filters from the highlight arguments\n filters = [Session.highlights == hl for hl in request.highlights]\n if not filters:\n raise endpoints.BadRequestException(\n 'At least one highlight must be s... | [
"0.79675597",
"0.5494635",
"0.5191284",
"0.5032431",
"0.5007258",
"0.49804562",
"0.48610216",
"0.4822324",
"0.48123288",
"0.47999722",
"0.47981682",
"0.47678235",
"0.47661048",
"0.47624898",
"0.47622135",
"0.47583574",
"0.4731185",
"0.4729603",
"0.46977532",
"0.4695372",
"0.4... | 0.6377008 | 1 |
Get list of sessions given by particular speaker. | def getSessionsBySpeaker(self, request):
sessions = self._getSessionsBySpeaker(request)
# Return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _getSessionsBySpeaker(self, request):\n # Ensure that the speaker key is valid and that the speaker exists\n speaker = _getEntityByWebsafeKey(request.websafeSpeakerKey, 'Speaker')\n # Return all of the speaker's sessions\n return ndb.get_multi(speaker.sessions)",
"def get_speaker_... | [
"0.8030544",
"0.7973326",
"0.7104441",
"0.69166255",
"0.673275",
"0.65312284",
"0.6531105",
"0.6509404",
"0.6405679",
"0.63847744",
"0.63358986",
"0.63214326",
"0.6302489",
"0.62991273",
"0.6233415",
"0.62318295",
"0.62300605",
"0.6215419",
"0.61713797",
"0.61546844",
"0.6126... | 0.7022974 | 3 |
Demonstrates my solution to the doubleinequality query problem. | def getSessionsDoubleInequalityDemo(self, request):
sessions = self._getSessionsDoubleInequalityDemo(request)
# Return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_dq_subquery_filter(self):\n # import ipdb; ipdb.set_trace()\n len1 = len(list(DQ('(b.id, b.name) Book{b.id in [\"(Book.id)\"]} b').dicts()))\n len2 = len(list(DQ(\"(Book.id)\").dicts()))\n self.assertEqual(len1, len2)",
"def query3() :",
"def test_multiple_iterations_work_p... | [
"0.62650895",
"0.61998206",
"0.6114937",
"0.60249525",
"0.6004869",
"0.5909111",
"0.58909786",
"0.5840364",
"0.58223784",
"0.57433224",
"0.57068557",
"0.5687743",
"0.5659272",
"0.5618641",
"0.5598052",
"0.55531514",
"0.55465287",
"0.5494882",
"0.54774994",
"0.54695725",
"0.54... | 0.0 | -1 |
Add a session to the user's wishlist. | def addSessionToWishlist(self, request):
return self._addSessionToWishlist(request) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_session_to_wishlist(self, request):\n return self.wishlist_service.add_session_to_wishlist(\n request.websafeSessionKey, endpoints.get_current_user())",
"def _addSessionToWishlist(self, request):\n # Preload necessary data items\n user = endpoints.get_current_user()\n ... | [
"0.8530634",
"0.8458863",
"0.81653136",
"0.6810031",
"0.67090017",
"0.63394535",
"0.6139774",
"0.6027772",
"0.60204995",
"0.5996146",
"0.5977719",
"0.5972456",
"0.5959016",
"0.5953108",
"0.59510666",
"0.5943294",
"0.59401596",
"0.5762732",
"0.5690296",
"0.5678126",
"0.5637029... | 0.8111066 | 3 |
Removes a session from the user's wishlist. | def removeSessionFromWishlist(self, request):
return self._removeSessionFromWishlist(request) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_session_from_wishlist(self, request):\n return self.wishlist_service.remove_session_from_wishlist(\n request.websafeSessionKey, endpoints.get_current_user())",
"def _removeSessionFromWishlist(self, request):\n # Preload necessary data items\n user = endpoints.get_curren... | [
"0.84345704",
"0.82142437",
"0.7982269",
"0.73392826",
"0.7275828",
"0.6940655",
"0.6902034",
"0.68524104",
"0.6489267",
"0.6463578",
"0.6454186",
"0.6400235",
"0.6364037",
"0.6338972",
"0.6291613",
"0.6269491",
"0.62286496",
"0.61994463",
"0.61216974",
"0.6110082",
"0.608531... | 0.81691545 | 2 |
Get list of sessions in the user's wishlist. | def getSessionsInWishlist(self, request):
sessions = self._getSessionsInWishlist()
# Return individual SessionForm object per Session
return SessionForms(
items=[self._copySessionToForm(session) for session in sessions]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def wishlist_sessions(self, user):\n wishlist_key = self.get_wishlist_key(user)\n session_keys = [ndb.Key(urlsafe=wsck) for wsck in\n wishlist_key.get().sessionKeys]\n sessions = ndb.get_multi(session_keys)\n return sessions",
"def get_sessions_in_wishlist(self,... | [
"0.85226977",
"0.82395834",
"0.8173087",
"0.79181445",
"0.76891893",
"0.74976784",
"0.699512",
"0.6882785",
"0.6687631",
"0.65706885",
"0.64425933",
"0.6409108",
"0.63482064",
"0.6346672",
"0.62671506",
"0.6256981",
"0.6236997",
"0.61917496",
"0.60747415",
"0.6055168",
"0.600... | 0.7137369 | 6 |
Copy relevant fields from Profile to ProfileForm. | def _copyProfileToForm(self, prof):
pf = ProfileForm()
for field in pf.all_fields():
if hasattr(prof, field.name):
# Convert t-shirt string to Enum; just copy others
if field.name == 'teeShirtSize':
setattr(pf, field.name,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_form_kwargs(self):\n kwargs = super(ProfileUpdate, self).get_form_kwargs()\n self.profile = self.get_object()\n extra_kwargs = {'profile': self.profile}\n kwargs.update(extra_kwargs)\n return kwargs",
"def _doProfile(self, save_request=None):\n prof = self._getPr... | [
"0.6958025",
"0.68784887",
"0.64856434",
"0.63592464",
"0.6284996",
"0.6272869",
"0.6269607",
"0.6214233",
"0.62111384",
"0.6183875",
"0.6135155",
"0.612614",
"0.61004287",
"0.6085827",
"0.60856766",
"0.6062952",
"0.59629256",
"0.58970684",
"0.5893775",
"0.5886109",
"0.587434... | 0.79479015 | 0 |
Get Profile and return to user, possibly updating it first. | def _doProfile(self, save_request=None):
prof = self._getProfileFromUser()
# If saveProfile(), process user-modifyable fields
if save_request:
for field in ('displayName', 'teeShirtSize'):
if hasattr(save_request, field):
val = getattr(save_request... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getProfile(self):\n # GET /profile\n debugMain('getProfile')\n return self._genericGet('/profile')",
"def get_user_profile(self):\n return self.user.profile",
"def _getProfileFromUser(self):\n # Make sure user is authenticated\n user = endpoints.get_current_user()\... | [
"0.7561392",
"0.7465786",
"0.7449008",
"0.740987",
"0.728692",
"0.72677916",
"0.71766216",
"0.71651495",
"0.70508856",
"0.7031329",
"0.695271",
"0.6945094",
"0.6902091",
"0.68805087",
"0.6845255",
"0.6826616",
"0.6815199",
"0.6798655",
"0.6770665",
"0.67508954",
"0.67319983",... | 0.0 | -1 |
Return Profile from datastore, creating new one if nonexistent. | def _getProfileFromUser(self):
# Make sure user is authenticated
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Get Profile from datastore
user_id = user.email()
p_key = ndb.Key(Profile, user_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, name='default'):\r\n if name not in self._cache:\r\n full_path = os.path.join(self._base_folder, name)\r\n self._create_if_needed(full_path)\r\n self._cache[name] = Profile(full_path, name)\r\n return self._cache[name]",
"def create_or_update_profile(s... | [
"0.67713064",
"0.6432612",
"0.638044",
"0.6346034",
"0.6343368",
"0.62816966",
"0.6173148",
"0.61137223",
"0.61025006",
"0.61001056",
"0.6060391",
"0.6048729",
"0.60413766",
"0.601181",
"0.5955292",
"0.5921494",
"0.5829891",
"0.58183765",
"0.5805473",
"0.5801193",
"0.5772561"... | 0.70515484 | 0 |
Update and return user profile. | def saveProfile(self, request):
return self._doProfile(request) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_profile():\n logger.debug(\"entering function update_profile\")\n response = update_user_profile(request.json)\n logger.debug(\"exiting function update_profile\")\n return jsonify(response)",
"def user_update_profile():\n \n if 'userid' and 'email' not in request.forms:\n retu... | [
"0.8200483",
"0.7872713",
"0.7602561",
"0.7440959",
"0.74367917",
"0.742381",
"0.74070036",
"0.7404673",
"0.7179691",
"0.7177466",
"0.71583205",
"0.71186864",
"0.71023077",
"0.709356",
"0.70908636",
"0.7064532",
"0.70350313",
"0.70142615",
"0.7012082",
"0.69845295",
"0.696759... | 0.6357891 | 89 |
Create our CRITsDBAPI object. You may specify a full mongodb uri or the arguments individually. | def __init__(self,
mongo_uri='',
mongo_host='localhost',
mongo_port=27017,
mongo_user='',
mongo_pass='',
db_name='crits'):
# If the user provided a URI, we will use that. Otherwise we will build
# a URI... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_mongodb(config):\n\n \n mongo_url = \"mongodb://\"\n mongo_url += \",\".join(map(lambda srv: srv['host'] + \":\" + str(srv['port']), config['data']['mongoServers']))\n \n if 'replica' in config['data']:\n mongo_url += \"/?replicaSet={0}\".format(config['data']['replica'])\n\n ... | [
"0.66846025",
"0.6621965",
"0.65577734",
"0.6492812",
"0.64823735",
"0.6253829",
"0.61448485",
"0.6078013",
"0.5876883",
"0.5867382",
"0.58658755",
"0.5850278",
"0.58107173",
"0.5787932",
"0.57878685",
"0.57876056",
"0.5785224",
"0.5769064",
"0.5743249",
"0.57387024",
"0.5737... | 0.6649437 | 1 |
Starts the mongodb connection. Must be called before anything else will work. | def connect(self):
self.client = MongoClient(self.mongo_uri)
self.db = self.client[self.db_name] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start(self) -> None:\n if not self._mongo_available:\n return\n operations_thread = threading.Thread(target=self._run, args=())\n operations_thread.setDaemon(True)\n operations_thread.start()",
"def start(self):\r\n \r\n if self.is_mongod_running():\r\n ... | [
"0.80308026",
"0.7978816",
"0.7448088",
"0.72025234",
"0.70190024",
"0.70040756",
"0.6830691",
"0.68217134",
"0.67718107",
"0.67625594",
"0.67552036",
"0.66018426",
"0.65349174",
"0.65215963",
"0.65146446",
"0.6464562",
"0.64335114",
"0.64177436",
"0.639432",
"0.6392853",
"0.... | 0.7607241 | 2 |
Search a collection for the query provided. Just a raw interface to mongo to do any query you want. | def find(self, collection, query):
obj = getattr(self.db, collection)
result = obj.find(query)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(self, collection, query=None, filter=None):\n return self.__db[collection].find(query, filter)",
"def find_document(collection: str, query: dict = None, regex: list = None) -> dict:\n if query is not None:\n return DB[collection].find_one(query)\n if regex is not None:\n r... | [
"0.7252133",
"0.7012578",
"0.6853299",
"0.6789239",
"0.66799027",
"0.6665288",
"0.6664408",
"0.65937394",
"0.6434959",
"0.6420416",
"0.6398617",
"0.62957525",
"0.628199",
"0.6266347",
"0.625643",
"0.62044865",
"0.6122247",
"0.6091136",
"0.6090586",
"0.60842377",
"0.6064155",
... | 0.76442003 | 0 |
Search a collection for all available items. | def find_all(self, collection):
obj = getattr(self.db, collection)
result = obj.find()
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all(collection):\n data = []\n for item in collection.find({}):\n data.append(item)\n return data",
"def searchItems(name, allPages = False):\n return Gw2Spidy._paginatedRequest(allPages, 'item-search', name)",
"def searchCollection(self, limit=100, **kwargs):\n ... | [
"0.66130906",
"0.6577022",
"0.6503677",
"0.64557165",
"0.62310874",
"0.61904126",
"0.6143242",
"0.6072285",
"0.60007083",
"0.59808266",
"0.5948115",
"0.59253854",
"0.58733493",
"0.5871716",
"0.5857312",
"0.58287",
"0.582313",
"0.5817589",
"0.57799107",
"0.57534194",
"0.575075... | 0.6775198 | 0 |
Search a collection for the query provided and return one result. Just a raw interface to mongo to do any query you want. | def find_one(self, collection, query):
obj = getattr(self.db, collection)
result = obj.find_one(query)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(self, collection, query):\n obj = getattr(self.db, collection)\n result = obj.find(query)\n return result",
"def find(self, collection, query=None, filter=None):\n return self.__db[collection].find(query, filter)",
"def find_document(collection: str, query: dict = None,... | [
"0.79049706",
"0.75223446",
"0.7400582",
"0.7219015",
"0.7148035",
"0.7044073",
"0.70365006",
"0.6900449",
"0.68693525",
"0.6687954",
"0.66815037",
"0.6643801",
"0.6433155",
"0.6354233",
"0.6272778",
"0.62644094",
"0.61989784",
"0.61437243",
"0.6137244",
"0.612182",
"0.609625... | 0.7865692 | 1 |
Search a collection for the distinct key values provided. | def find_distinct(self, collection, key):
obj = getattr(self.db, collection)
result = obj.distinct(key)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _filter_search_values(key: str, values: list, collection: list):\n return_data = []\n for item in collection:\n if any(val in values for val in item[key]):\n return_data.append(item)\n return return_data",
"def distinct(self, key):\n return self.database.command({'distinct':... | [
"0.69668233",
"0.58777803",
"0.5819709",
"0.5781459",
"0.5655128",
"0.5622824",
"0.56214416",
"0.56086063",
"0.5562973",
"0.5557258",
"0.5502194",
"0.5408141",
"0.5392551",
"0.53712016",
"0.5323929",
"0.5288685",
"0.5286743",
"0.52866507",
"0.5135332",
"0.51346934",
"0.513088... | 0.72450334 | 0 |
Adds an embedded campaign to the TLO. | def add_embedded_campaign(self, id, collection, campaign, confidence,
analyst, date, description):
if type(id) is not ObjectId:
id = ObjectId(id)
# TODO: Make sure the object does not already have the campaign
# Return if it does. Add it if it doesn't
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_campaign(self, campaign):\n self._campaigns += [campaign]",
"def _set_campaign(self, campaign):\n if isinstance(campaign, str):\n campaign = TrackedCampaign.objects.create(name=campaign)\n\n campaign.save()\n\n self.campaign = campaign",
"def campaign(self, campai... | [
"0.7053185",
"0.55294055",
"0.5502619",
"0.53983206",
"0.53974485",
"0.53938943",
"0.5390333",
"0.5346445",
"0.51280814",
"0.51132816",
"0.5100033",
"0.5023265",
"0.4961767",
"0.49532866",
"0.49409008",
"0.49400547",
"0.49252018",
"0.49178767",
"0.48796228",
"0.48726276",
"0.... | 0.7287195 | 0 |
Removes an item from the bucket list | def remove_bucket_list_item(self, id, collection, item):
if type(id) is not ObjectId:
id = ObjectId(id)
obj = getattr(self.db, collection)
result = obj.update(
{'_id': id},
{'$pull': {'bucket_list': item}}
)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, item):\n try:\n entry = self.set.pop(item)\n entry[-1] = self.REMOVED\n except KeyError:\n print(\"Can't remove a non-existing item\")",
"def remove(self, item):\n del self._dict[item]",
"def _bucket_delitem(self, j, k):\n pass",
"def ... | [
"0.791302",
"0.7706514",
"0.7652778",
"0.75784016",
"0.7561372",
"0.7506943",
"0.74443907",
"0.7405826",
"0.7405826",
"0.73899317",
"0.73899317",
"0.73878163",
"0.73668784",
"0.7335001",
"0.7286636",
"0.7273813",
"0.72560424",
"0.72402847",
"0.72392786",
"0.72225547",
"0.7219... | 0.8045885 | 0 |
Adds an item to the bucket list | def add_bucket_list_item(self, id, collection, item):
if type(id) is not ObjectId:
id = ObjectId(id)
obj = getattr(self.db, collection)
result = obj.update(
{'_id': id},
{'$addToSet': {'bucket_list': item}}
)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, item):",
"def add_item(self, item):\n self.items.append(item)",
"def add_to_bag(self, item):\n self._bag.append(item)",
"def add(self, item):\n\n if item not in self:\n self._index_map[item] = len(self._list)\n self._list.append(item)",
"def add(self... | [
"0.7640922",
"0.75756705",
"0.751956",
"0.74900144",
"0.7369312",
"0.7361309",
"0.7332356",
"0.7283963",
"0.7280235",
"0.72764546",
"0.72698563",
"0.7263061",
"0.72285056",
"0.72285056",
"0.72285056",
"0.72285056",
"0.72285056",
"0.71988684",
"0.7163348",
"0.7156221",
"0.7156... | 0.77858466 | 0 |
Returns a list of all valid campaign names | def get_campaign_name_list(self):
campaigns = self.find('campaigns', {})
campaign_names = []
for campaign in campaigns:
if 'name' in campaign:
campaign_names.append(campaign['name'])
return campaign_names | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_existent_campaigns_returns_campaigns_list(self):\n test_campaign = return_canned_campaign()\n test_campaign.create()\n response = self.client.get(self.endpoint_url)\n response_body = response.get_json()\n self.assertEqual(response.status_code, 200)\n self.asse... | [
"0.5988995",
"0.5805326",
"0.5684534",
"0.5676261",
"0.5601181",
"0.55940896",
"0.5530269",
"0.5515312",
"0.5460801",
"0.5450627",
"0.5449519",
"0.54434097",
"0.54434097",
"0.54434097",
"0.542792",
"0.5424966",
"0.54231083",
"0.54181385",
"0.53910905",
"0.5375468",
"0.5351693... | 0.7925846 | 0 |
Whether DDP is activated | def is_distributed(args: dict) -> bool:
return args.local_rank != -1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _ison(self):\n return self.dp.state()==PyTango.DevState.ON",
"def is_on(self) -> bool:\n return self.tuya_device.status.get(DPCODE_SWITCH, False)",
"def _is_device_active(self):\n return self.power_mode == STATE_ON",
"def is_active():\n return True",
"def is_active(self) -> ... | [
"0.7000938",
"0.6990944",
"0.68319756",
"0.6827091",
"0.6824075",
"0.6731119",
"0.6713643",
"0.6683036",
"0.66403025",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
"0.6593317",
... | 0.0 | -1 |
Whether the process is running as the main process | def is_main_process(args: dict):
return not is_distributed(args) or args.local_rank == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_main_process() -> bool:\n return multiprocessing.current_process().name == 'MainProcess' and os.environ['main_process_pid'] == str(os.getpid())",
"def _isSubProcessRunning(self): \n # Check if child process has terminated. Set and return returncode attribute.\n if self.__process.poll()... | [
"0.8799151",
"0.7497712",
"0.7343165",
"0.7201382",
"0.7150669",
"0.7103503",
"0.7073254",
"0.7026223",
"0.70111364",
"0.6951164",
"0.6927277",
"0.6923171",
"0.68789256",
"0.68608314",
"0.68460107",
"0.68151265",
"0.6789779",
"0.67896146",
"0.67687416",
"0.6764666",
"0.674240... | 0.7922667 | 1 |
Initializes the DDP process pool and sets the default device | def init_distributed(args: dict):
if is_distributed(args):
dist.init_process_group(backend="nccl")
torch.cuda.set_device(args.local_rank) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setUp(self):\n super().setUp()\n self.devices = _DEVICE_STRATEGY()\n command_line = [\"pool\", \"create\", self._POOLNAME] + self.devices\n RUNNER(command_line)",
"def setup_device(device):\n try:\n # Gets around \"Resource busy\" errors\n device.detach_kernel_dri... | [
"0.6002063",
"0.5892538",
"0.58575326",
"0.5846637",
"0.5833589",
"0.58189595",
"0.57568073",
"0.5730799",
"0.55829",
"0.55799645",
"0.55763",
"0.55616033",
"0.55581534",
"0.5522597",
"0.5496948",
"0.5489952",
"0.54753715",
"0.54609555",
"0.5448769",
"0.544637",
"0.5446346",
... | 0.56588197 | 8 |
Gets the default device | def get_device(args: dict) -> torch.device:
if is_distributed(args):
device = torch.device("cuda", args.local_rank)
else:
if torch.cuda.is_available():
device = torch.device("cuda", 0)
else:
device = torch.device("cpu")
return device | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_default_device():\n global _default_device\n\n if _default_device is None:\n import wgpu.backends.rs # noqa\n\n adapter = wgpu.request_adapter(canvas=None, power_preference=\"high-performance\")\n _default_device = adapter.request_device()\n return _default_device",
"def ge... | [
"0.85560495",
"0.8509156",
"0.81830615",
"0.7949495",
"0.7936597",
"0.7936597",
"0.7936597",
"0.7936597",
"0.765728",
"0.75626457",
"0.7489031",
"0.74441177",
"0.7370417",
"0.73445976",
"0.72786206",
"0.72608113",
"0.72608113",
"0.72608113",
"0.72608113",
"0.72608113",
"0.722... | 0.0 | -1 |
Cleanups ddp process group | def deinit_distributed(args: dict):
if is_distributed(args):
dist.destroy_process_group() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_up(self):\n dist.destroy_process_group()",
"def cleanup():\n dist.destroy_process_group()",
"def dist_cleanup():\n dist.destroy_process_group()",
"def destroy(self, process_group: ProcessGroup = None):\n dist.destroy_process_group(process_group)",
"def clean_all(self):\n fo... | [
"0.7584239",
"0.73850125",
"0.70272577",
"0.66014636",
"0.64747924",
"0.6219315",
"0.6033827",
"0.5908748",
"0.5872821",
"0.58509606",
"0.5828625",
"0.5803862",
"0.5777883",
"0.5747657",
"0.5744301",
"0.5668658",
"0.5653742",
"0.563985",
"0.5636443",
"0.5628545",
"0.5613895",... | 0.6236989 | 5 |
print the character frequency in a file | def character_frequency(filename):
try:
f = open(filename)
except OSError:
return None
characcters = {}
for line in f:
for char in line:
characcters[char] = characcters.get(char, 0) +1
f.close()
return characcters | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cnt_freq(filename):\n freq = [0] * 256\n try:\n f_in = open(filename,'r')\n except:\n raise FileNotFoundError\n for line in f_in:\n for char in line:\n freq[ord(char)] = freq[ord(char)] + 1\n f_in.close()\n return freq",
"def cnt_freq(filename):\r\n counts... | [
"0.7926811",
"0.78219485",
"0.75066334",
"0.74771833",
"0.7068149",
"0.69391334",
"0.69081545",
"0.6878811",
"0.686783",
"0.68351465",
"0.67606854",
"0.6759828",
"0.67133343",
"0.6663235",
"0.6577101",
"0.64824665",
"0.64137924",
"0.641095",
"0.63741547",
"0.6366009",
"0.6353... | 0.7556631 | 2 |
Initialize the WorkshopAdapter object. This constructor initializes the WorkshopAdapter object. | def __init__(self, **kwargs):
# Intialise superclass
super(FileInterfaceAdapter, self).__init__(**kwargs)
self.abs_directory = str(self.options.get('absolute_directory'))
self.fileInterface = FileInterface(self.abs_directory)
logging.debug('FileInterface Adapter loaded') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.currencies = {\n currency.code: currency for currency in Currency.objects.all()\n }\n self.channels = {\n channel.sub_source: channel.channel\n for channel in LinnworksChannel.objects.all()\n }\n self.countries = {\n ... | [
"0.5742074",
"0.571112",
"0.5694404",
"0.5597881",
"0.5553317",
"0.55303854",
"0.5501522",
"0.5488599",
"0.54834014",
"0.54664266",
"0.5454657",
"0.54337347",
"0.54020715",
"0.5397585",
"0.5397585",
"0.538841",
"0.5384996",
"0.53681713",
"0.53575194",
"0.529976",
"0.5297414",... | 0.0 | -1 |
Handle an HTTP GET request. This method handles an HTTP GET request, returning a JSON response. | def get(self, path, request):
try:
response = self.fileInterface.get(path)
status_code = 200
except ParameterTreeError as e:
response = {'error': str(e)}
status_code = 400
content_type = 'application/json'
return ApiAdapterResponse(respon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_GET(self):\r\n self._send_handler_response('GET')",
"def do_GET(self):\n self._try_to_process_request(self._handle_get_request)",
"def do_GET(self):\n self.http_method = 'GET'\n self.response()",
"def get(self, *args, **kwargs):\n return self.handle_get_request()",
... | [
"0.73754185",
"0.72471803",
"0.7157816",
"0.70633495",
"0.692195",
"0.6795289",
"0.6795289",
"0.67720217",
"0.67569727",
"0.67546445",
"0.6660707",
"0.6651187",
"0.65724033",
"0.65541583",
"0.65337265",
"0.651263",
"0.6496506",
"0.6482216",
"0.6457152",
"0.6453102",
"0.642113... | 0.0 | -1 |
Handle an HTTP PUT request. This method handles an HTTP PUT request, returning a JSON response. | def put(self, path, request):
content_type = 'application/json'
try:
data = json_decode(request.body)
self.fileInterface.set(path, data)
response = self.fileInterface.get(path)
status_code = 200
except FileInterfaceError as e:
respons... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_PUT(self,):\n self.http_method = 'PUT'\n # Nothing to do for now.\n pass",
"def put(self, *args, **kwargs):\n return self.handle_put_request()",
"def handle_put(self, api, command):\n return self._make_request_from_command('PUT', command)",
"def PUT(self):\n r... | [
"0.7208754",
"0.7198427",
"0.70180017",
"0.70172656",
"0.68714666",
"0.6849794",
"0.6794865",
"0.6794865",
"0.6794865",
"0.6720018",
"0.67168677",
"0.6708451",
"0.66553783",
"0.6645579",
"0.6639994",
"0.6630718",
"0.65911204",
"0.6553887",
"0.65157974",
"0.64955133",
"0.64950... | 0.6513424 | 19 |
Handle an HTTP DELETE request. This method handles an HTTP DELETE request, returning a JSON response. | def delete(self, path, request):
response = 'FileInterfaceAdapter: DELETE on path {}'.format(path)
status_code = 200
logging.debug(response)
return ApiAdapterResponse(response, status_code=status_code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\r\n return http.Request('DELETE', '{0}'.format(\r\n self.get_url())), parsers.parse_json",
"def do_DELETE(self,):\n self.http_method = 'DELETE'\n self.response()",
"def httpDelete(self, url='', data='', params={}, headers={}):\n\n return ... | [
"0.7570553",
"0.753795",
"0.7233657",
"0.72140676",
"0.7095827",
"0.69700193",
"0.69198775",
"0.6910894",
"0.69087464",
"0.6906033",
"0.68964475",
"0.6865279",
"0.6833366",
"0.68176347",
"0.66972923",
"0.66895145",
"0.6677972",
"0.6655997",
"0.66559964",
"0.6639792",
"0.66364... | 0.60661227 | 77 |
Initialise the FileInterface object. This constructor initlialises the FileInterface object, building a parameter tree. | def __init__(self, abs_directory):
# Save arguments
self.fp_config_files = []
self.txt_files = []
self.fr_config_files = []
self.abs_directory = abs_directory
# Store initialisation time
self.init_time = time.time()
# Get package version information
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, **kwargs):\n # Intialise superclass\n super(FileInterfaceAdapter, self).__init__(**kwargs)\n self.abs_directory = str(self.options.get('absolute_directory'))\n self.fileInterface = FileInterface(self.abs_directory)\n\n logging.debug('FileInterface Adapter loade... | [
"0.7568297",
"0.6816404",
"0.6792019",
"0.67573327",
"0.66559887",
"0.6599961",
"0.65831435",
"0.650752",
"0.6437159",
"0.64053744",
"0.6384164",
"0.6318538",
"0.6318299",
"0.63178724",
"0.6264322",
"0.62354314",
"0.622551",
"0.622551",
"0.62203366",
"0.6199047",
"0.6189019",... | 0.59067506 | 75 |
Get the uptime for the ODIN server. This method returns the current uptime for the ODIN server. | def get_server_uptime(self):
return time.time() - self.init_time | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def uptime(self):\n return self._uptime",
"def uptime(self):\n if self._uptime is None:\n version_data = self._raw_version_data()\n uptime_full_string = version_data[\"uptime\"]\n self._uptime = self._uptime_to_seconds(uptime_full_string)\n\n return self._upt... | [
"0.8274161",
"0.80681056",
"0.8065809",
"0.7863143",
"0.74871224",
"0.7299963",
"0.7203934",
"0.7076993",
"0.7023769",
"0.7021257",
"0.69755334",
"0.68817836",
"0.68444324",
"0.68224293",
"0.67419744",
"0.6637767",
"0.65656966",
"0.6540984",
"0.6523476",
"0.65107214",
"0.6489... | 0.794025 | 3 |
Get the parameter tree. This method returns the parameter tree for use by clients via the FileInterface adapter. | def get(self, path):
return self.param_tree.get(path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parameters(self) -> PyTree:\n return self._parameters",
"def filetree(self) -> P:\n ...",
"def parameterNode(self):\r\n # framework\r\n profbox()\r\n return self.parameterNode",
"def parameterNode(self):\n #framework\n profbox()\n return self.parameterNode",
"def get_par... | [
"0.75262344",
"0.6833905",
"0.65000045",
"0.6114677",
"0.6060483",
"0.6060483",
"0.6060483",
"0.6060483",
"0.6060483",
"0.60557586",
"0.59406596",
"0.59071493",
"0.58923465",
"0.58923465",
"0.5843873",
"0.58284414",
"0.5816218",
"0.5750005",
"0.5725853",
"0.5725853",
"0.57237... | 0.5403514 | 81 |
Set parameters in the parameter tree. This method simply wraps underlying ParameterTree method so that an exceptions can be reraised with an appropriate FileInterfaceError. | def set(self, path, data):
try:
self.param_tree.set(path, data)
except ParameterTreeError as e:
raise FileInterfaceError(e) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setParameterNode(self, parameterNode):\r\n # framework\r\n profbox()\r\n self.parameterNode = parameterNode",
"def setParameterNode(self, parameterNode):\n #framework\n profbox()\n self.parameterNode = parameterNode",
"def setParams(self, paramSet):\r\n pass",
"def set_params(self):\... | [
"0.6985717",
"0.67060566",
"0.6683662",
"0.66480035",
"0.6634291",
"0.66082174",
"0.65245366",
"0.6508125",
"0.64559436",
"0.6373968",
"0.6365402",
"0.63510525",
"0.63371843",
"0.62663895",
"0.6263053",
"0.6206298",
"0.6145241",
"0.6132779",
"0.609262",
"0.6084063",
"0.608083... | 0.7035647 | 0 |
Retrieve all of the txt configuration files in the absolute directory path Clears the internal lists first to prevent circular appending at every "GET" | def get_config_files(self):
self.clear_lists()
print self.abs_directory
for file in os.listdir(self.abs_directory):
print file
if file.endswith('.json') and "qemii" in file:
self.txt_files.append(file) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_path(self, conf):\n\t\tpass",
"def get_cfg_files(self):\n\t\tcfg_files = []\n\t\tfor config_object, config_value in self.maincfg_values:\n\t\t\t\n\t\t\t## Add cfg_file objects to cfg file list\n\t\t\tif config_object == \"cfg_file\" and os.path.isfile(config_value):\n\t\t\t\t\tcfg_files.append(config... | [
"0.67695117",
"0.6177163",
"0.617072",
"0.59774256",
"0.59301084",
"0.5873713",
"0.58602625",
"0.58550894",
"0.58476",
"0.58326143",
"0.57421196",
"0.5723155",
"0.57174045",
"0.5698926",
"0.56854516",
"0.56496686",
"0.5622283",
"0.56196785",
"0.5619165",
"0.55947644",
"0.5593... | 0.7291427 | 0 |
gets the frame processor config files from the list of text files found | def get_fp_config_files(self):
self.get_config_files()
for file in self.txt_files:
if "fp" in file:
self.fp_config_files.append(file)
return self.fp_config_files | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fr_config_files(self):\n self.get_config_files()\n for file in self.txt_files:\n if \"fr\" in file:\n self.fr_config_files.append(file)\n return self.fr_config_files",
"def get_config_files(self):\n self.clear_lists()\n print self.abs_directory... | [
"0.6520556",
"0.63628197",
"0.63615507",
"0.6221763",
"0.5962912",
"0.5892015",
"0.5830065",
"0.5739405",
"0.57229286",
"0.56986266",
"0.5679086",
"0.5662258",
"0.5656805",
"0.5652418",
"0.5599099",
"0.5556959",
"0.5527652",
"0.5507178",
"0.5476617",
"0.5443827",
"0.5414869",... | 0.68645674 | 0 |
gets the frame receiver config files from the list of text files found | def get_fr_config_files(self):
self.get_config_files()
for file in self.txt_files:
if "fr" in file:
self.fr_config_files.append(file)
return self.fr_config_files | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_config_files(self):\n self.clear_lists()\n print self.abs_directory\n for file in os.listdir(self.abs_directory):\n print file\n if file.endswith('.json') and \"qemii\" in file:\n self.txt_files.append(file)",
"def get_fp_config_files(self):\n ... | [
"0.7247125",
"0.68345076",
"0.662452",
"0.6256014",
"0.61033165",
"0.60573196",
"0.6044879",
"0.5955532",
"0.59343725",
"0.5895655",
"0.5890608",
"0.5874388",
"0.58420765",
"0.5819668",
"0.5817432",
"0.5767008",
"0.57370996",
"0.5723543",
"0.57066727",
"0.5687508",
"0.5678910... | 0.6701927 | 2 |
clears the text file, fr and fp config file lists | def clear_lists(self):
self.fp_config_files = []
self.txt_files = []
self.fr_config_files = [] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clear():",
"def clean_files(self):\n self.filenames.clear()",
"def clear_specific(self):\n self.specific_file = None\n self.specific_parser = None\n\n self.specific_box.delete(0, END)",
"def _clear_variables( self ):\r\n self.navigation = None\r\n self.resPath = ... | [
"0.6580808",
"0.656783",
"0.6490422",
"0.64671326",
"0.6438465",
"0.64325815",
"0.6405157",
"0.63748187",
"0.6326406",
"0.63253486",
"0.6313617",
"0.6293512",
"0.6253082",
"0.6251729",
"0.62491286",
"0.6137878",
"0.61237454",
"0.6122098",
"0.6118917",
"0.6106766",
"0.61034346... | 0.8425523 | 0 |
Initialize the object, getting the overlap integral matrix. | def __init__(self, cbins=None, rbins=None, thbins=None, file=None):
if isinstance(cbins, str) or isinstance(cbins, File):
file = cbins
rbins, thbins = None, None
if cbins and rbins and thbins:
self.cbins = cbins
self.rbins = rbins
self.thbins = thbins
rs, ths, xs, ys, vals = self.get_overlap_v... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Initialize(self):\n return _gmat_py.Integrator_Initialize(self)",
"def __init__(self):\n self.Robot = Robot()\n self.Omega = matrix()\n # self.Omega.value[0][0] = 1.0\n # self.Omega.value[1][1] = 1.0\n self.Xi = matrix()\n # Xi.value[0][0] = 0.0\n # Xi.... | [
"0.6030348",
"0.58474874",
"0.57042056",
"0.5693674",
"0.5682293",
"0.56683475",
"0.56358224",
"0.554552",
"0.5544686",
"0.55268455",
"0.55076176",
"0.5495157",
"0.5480548",
"0.54716593",
"0.54712325",
"0.54395574",
"0.5426868",
"0.5418678",
"0.541668",
"0.54087013",
"0.53720... | 0.0 | -1 |
Get the radii (in pixels) corresponding to each radial bin. | def R(self):
return (arange(self.rbins) + 0.5) * (self.cbins - 0.5) / self.rbins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_radii(self) -> np.ndarray:\n return np.array([self._radii[p] for p in self.particles])",
"def radii(self):\n dim_half = (self.shape[0] + 1) // 2\n x = np.arange(dim_half)\n if self.step is None:\n return x\n else:\n xmax = x.max()\n x2 =... | [
"0.69543964",
"0.6813362",
"0.6594828",
"0.6583719",
"0.6409623",
"0.6281537",
"0.6247055",
"0.6237292",
"0.6164095",
"0.61313295",
"0.6103718",
"0.6100923",
"0.60824674",
"0.60633904",
"0.60296583",
"0.5983751",
"0.59354424",
"0.59351385",
"0.59231746",
"0.5907882",
"0.59038... | 0.67343485 | 2 |
Get the angles (in radians) corresponding to each angular bin. | def TH(self, full=False):
return (arange(self.thbins + 3*self.thbins*(full==True)) + 0.5) * (pi / 2) / self.thbins | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def angles(self):\n self._sort_measurements()\n return self._angles",
"def angles(self):\n return self._angles",
"def angles(self):\n penult = self._coordinates[-2]\n last = self._coordinates[-1]\n angles = []\n for c in self._coordinates:\n angle = (... | [
"0.7416226",
"0.72830087",
"0.7281555",
"0.7212214",
"0.70486593",
"0.7032604",
"0.6986233",
"0.69393504",
"0.6924365",
"0.66856015",
"0.6669014",
"0.66409254",
"0.6580863",
"0.65750813",
"0.6529892",
"0.65235746",
"0.6478025",
"0.6461709",
"0.6380902",
"0.63770735",
"0.63730... | 0.0 | -1 |
Rebin cartesian image or cartesian quadrant to polar data or polar quadrant. | def cart2pol(self, cart, x0=None, y0=None):
if x0 and y0:
return hstack((fliplr(self.cart2pol(resizeFolded(foldQuadrant(cart, x0, y0, [1,0,0,0]), self.cbins))),
self.cart2pol(resizeFolded(foldQuadrant(cart, x0, y0, [0,1,0,0]), self.cbins)),
fliplr(self.cart2pol(resizeFolded(foldQuadrant(cart, x... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reproject_image_into_polar(data, origin=None):\r\n ny, nx = data.shape[:2]\r\n if origin is None:\r\n origin = (nx//2, ny//2)\r\n\r\n # Determine that the min and max r and theta coords will be...\r\n x, y = index_coords(data, origin=origin)\r\n r, theta = cart2polar(x, y)\r\n\r\n # Ma... | [
"0.6475095",
"0.6117494",
"0.6110443",
"0.60577464",
"0.60224247",
"0.5961014",
"0.5882974",
"0.5875506",
"0.58316296",
"0.5820953",
"0.5778836",
"0.57175505",
"0.5717419",
"0.56958276",
"0.5621838",
"0.55780774",
"0.5545729",
"0.55400836",
"0.54864264",
"0.5484192",
"0.54762... | 0.0 | -1 |
Rebin polar image or polar quadrant to cartesian image or cartesian quadrant. | def pol2cart(self, pol):
if pol.shape[1]==self.thbins:
areas = 2 * pi * self.R() / 4 / self.thbins
return self.overlap_values.T.dot((pol.T/areas).T.reshape(self.rbins*self.thbins, -1)).reshape(self.cbins, self.cbins, *pol.shape[2:])
elif pol.shape[1]==self.thbins*4:
cart = zeros((self.cbins*2 - 1, self.cb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cartesian2polar(x, y):\n r = (x**2+y**2)**.5\n phi = atan2(y, x)\n return phi, r",
"def cartesian_to_polar(cart: np.ndarray, radial_step: float, azimuth_step : float, radial_bins: int,\n azimuth_bins: int, cart_resolution: float) -> np.ndarray:\n max_range = radial_step * radial_bins\n ... | [
"0.61145186",
"0.60511214",
"0.6048923",
"0.6003735",
"0.5971528",
"0.59478134",
"0.5923697",
"0.5781841",
"0.5757597",
"0.5742307",
"0.57259274",
"0.57149446",
"0.5707129",
"0.5706045",
"0.5620117",
"0.5614398",
"0.5573024",
"0.5547646",
"0.5528825",
"0.5497579",
"0.5455968"... | 0.47288632 | 81 |
Save the overlap integral values to file. | def save(self, rs, ths, xs, ys, vals, file=None):
if file is None:
file = 'PR_c%d_r%d_th%d.h5' % (self.cbins, self.rbins, self.thbins)
with File(file, 'w') as file:
file.create_dataset('cbins' , data=self.cbins)
file.create_dataset('rbins' , data=self.rbins)
file.create_dataset('thbins', data=self.thb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_enu(self, filename):\n x, y, z = self.get_coords_enu()\n coords = np.vstack([x, y, z]).T\n np.savetxt(filename, coords, fmt=b'%.12e')",
"def save(self, fname):\n fmt = \" %7.1f %7.1f %8.2f %8.2f %8.2f %8.3f %8.3f %8.3f %8.3f %6.1f\"\n with open(fname, 'wb') as fid:\n ... | [
"0.6437546",
"0.6042619",
"0.5867301",
"0.58298796",
"0.57658714",
"0.5632551",
"0.56270516",
"0.5551496",
"0.5534138",
"0.55244094",
"0.5514841",
"0.5507916",
"0.5505046",
"0.549569",
"0.5495044",
"0.5490334",
"0.54699355",
"0.54660064",
"0.54602015",
"0.54510903",
"0.545045... | 0.0 | -1 |
Find the overlap areas between each cartesian bin and each polar bin. | def get_overlap_values(self, cbins, rbins, thbins):
dr = (cbins - 0.5) / rbins
dth = (pi / 2) / thbins
thbins_reduced = int(ceil(thbins / 2))
def overlap_value(x, y, r, th):
"""
Find the overlap area between a cartesian and a polar bin.
"""
thmin = max(th - dth/2, atan2(y - 0.5, x + 0.5))
thma... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def face_area(lon_b, lat_b, r_sphere = 6.375e6):\n \n # Convert inputs to radians\n lon_b_rad = lon_b * np.pi / 180.0\n lat_b_rad = lat_b * np.pi / 180.0\n \n r_sq = r_sphere * r_sphere\n n_cs = lon_b.shape[1] - 1\n \n # Allocate output array\n cs_area = np.zeros((n_cs,n_cs))\n \n ... | [
"0.6044802",
"0.5895329",
"0.58889174",
"0.58684486",
"0.5833127",
"0.58256036",
"0.5822762",
"0.58167046",
"0.5789582",
"0.5789443",
"0.57723266",
"0.5764114",
"0.5745368",
"0.57442003",
"0.57348084",
"0.57329583",
"0.56990653",
"0.56981635",
"0.5677911",
"0.5641722",
"0.564... | 0.72021544 | 0 |
Find the overlap area between a cartesian and a polar bin. | def overlap_value(x, y, r, th):
thmin = max(th - dth/2, atan2(y - 0.5, x + 0.5))
thmax = min(th + dth/2, atan2(y + 0.5, x - 0.5))
rin = lambda theta: maximum(r - dr/2, maximum((x - 0.5) / npcos(theta), (y - 0.5) / npsin(theta)))
rout = lambda theta: minimum(r + dr/2, minimum((x + 0.5) / npcos(theta), (y ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_overlap_values(self, cbins, rbins, thbins):\n\n\t\tdr = (cbins - 0.5) / rbins\n\t\tdth = (pi / 2) / thbins\n\t\tthbins_reduced = int(ceil(thbins / 2))\n\n\t\tdef overlap_value(x, y, r, th):\n\t\t\t\"\"\"\n\t\t\tFind the overlap area between a cartesian and a polar bin.\n\t\t\t\"\"\"\n\n\t\t\tthmin = max(th... | [
"0.7028766",
"0.59871954",
"0.5846108",
"0.58240885",
"0.5822711",
"0.5804281",
"0.57852316",
"0.5781865",
"0.5740109",
"0.5740109",
"0.57282335",
"0.57139766",
"0.56880105",
"0.56870973",
"0.5682105",
"0.56815344",
"0.5678309",
"0.56728154",
"0.5672636",
"0.5653654",
"0.5644... | 0.5345977 | 55 |
Construct the sparse overlap integral matrix from the nonzero elements. | def make_matrix(self, rs, ths, xs, ys, vals):
ps = ravel_multi_index((hstack((rs, rs)), hstack((ths, self.thbins - ths - 1))), (self.rbins, self.thbins))
cs = ravel_multi_index((hstack((xs, ys)), hstack((ys, xs))), (self.cbins, self.cbins))
return csr_matrix((hstack((vals, vals)), (ps, cs)), (self.rbins*self.th... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makesparse(matrix):\n n = matrix[0].size\n elements = []\n for i in range(n):\n for j in range(n):\n if matrix[i][j] != 0 :\n temp = MatrixElement(i, j, matrix[i][j])\n elements.append(temp)\n return SparseMatrix(n, elements)",
"def ident_zeros(A):\... | [
"0.66588247",
"0.6175007",
"0.6145749",
"0.612834",
"0.6091433",
"0.60378534",
"0.598065",
"0.5979184",
"0.5858971",
"0.585185",
"0.58418506",
"0.583919",
"0.5835888",
"0.5825546",
"0.5802874",
"0.57908213",
"0.57894164",
"0.5752835",
"0.5750317",
"0.57402164",
"0.57259",
"... | 0.0 | -1 |
Method to toggle the is_running boolean in the game | def pause(self, _):
if not self.is_ended:
self.canvas.create_text(self.game.width // 2,
self.game.height // 2,
text="Paused",
font=(Game.FONT, 50),
fill=Gam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_running(self):\n self.running = False",
"def toggle(self):\n self._state.is_on = not self._state.is_on\n self.send_command(Command.TOGGLE, [])",
"def toggle_run_button(self, event):\n if not self.running:\n self.start_thread()\n else:\n self.stop_thread... | [
"0.70615935",
"0.6840273",
"0.6838203",
"0.6742316",
"0.6737016",
"0.6685446",
"0.6516571",
"0.6506268",
"0.6505636",
"0.6505636",
"0.6505636",
"0.6497265",
"0.64862645",
"0.64459693",
"0.64438826",
"0.64438826",
"0.6413608",
"0.64024734",
"0.63971186",
"0.6395969",
"0.639596... | 0.0 | -1 |
Simply a setter for the switch_state variable | def switch_to_state(self, state):
self.switch_state = state | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_state(self, state: int):",
"def set_state(self,s):\n self.state = s",
"def set_state(self, value):\n self.state = value",
"def set_state( self ):",
"def __change_state(self, state):\n self.state = state",
"def _set_state(self, state):\n #print(\"** set state from %d to... | [
"0.7938014",
"0.77415305",
"0.77284354",
"0.7591089",
"0.7483043",
"0.74070084",
"0.74032426",
"0.73946637",
"0.7236219",
"0.722214",
"0.72149825",
"0.7191996",
"0.71756476",
"0.7167509",
"0.7059652",
"0.7028504",
"0.70257914",
"0.69464743",
"0.6940021",
"0.69133204",
"0.6864... | 0.7992266 | 0 |
Used for resetting everything currently on the game window. This is used for switching between states. The code is small, but commonly used, so I made it a function. | def reset_frame(self):
if self.frame is not None:
self.frame.destroy()
self.frame = Frame(self.root,
width=self._width,
height=self._height,
bg=Game.BACKGROUND_COLOUR)
self.frame.pack() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reset(self):\n\n game.reset()\n sm.get_screen('game_screen').reset()",
"def reset_game():\n global x_pos, o_pos, frames, count\n\n count = 0\n x_pos = []\n o_pos = []\n result.set(\"Your Turn!\")\n for x in frames:\n for y in x.winfo_children():\n y.config(te... | [
"0.7740354",
"0.7462945",
"0.7380994",
"0.70991206",
"0.7090645",
"0.7058696",
"0.69993645",
"0.6983626",
"0.6981798",
"0.69441324",
"0.69441324",
"0.6944032",
"0.6944032",
"0.6944032",
"0.6941165",
"0.6921576",
"0.691852",
"0.6903168",
"0.68667805",
"0.6865117",
"0.6856101",... | 0.0 | -1 |
preprocess the "NEW" Best Buy review data frame | def write_bestbuy_review_data(engine, api = 'http://api.remix.bestbuy.com/v1/reviews?format=json&pageSize=100&apiKey=q3yfbu6smh6bzydeqbjv9kas'):
# delete the unnecesssary records
reviews_data = preproc.getData_API(api, 'reviews')
if('aboutMe' in reviews_data.columns):
del reviews_data['aboutMe']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def single_review_prep(text):\n clean_test = data_cleaner(text)\n dummy_dict= {'star': [clean_test]}\n clean_test_df = pd.DataFrame(dummy_dict)\n return clean_test_df",
"def preprocess_data(df, min_vote_count=1000):\n # note that order matters!\n df = remove_rows_without_feature(df, 'budget')\n... | [
"0.6396756",
"0.59188193",
"0.58962667",
"0.5809514",
"0.5796008",
"0.5783609",
"0.5739264",
"0.5638419",
"0.56384134",
"0.56228554",
"0.56181115",
"0.55560744",
"0.551565",
"0.54739445",
"0.54389805",
"0.5418286",
"0.5389239",
"0.53320706",
"0.53245866",
"0.5295883",
"0.5290... | 0.5433427 | 15 |
preprocess the "NEW" Best Buy review data frame | def write_bestbuy_product_data(engine, api = 'http://api.remix.bestbuy.com/v1/products?format=json&pageSize=100&apiKey=q3yfbu6smh6bzydeqbjv9kas'):
# delete the unnecesssary records
products_data = preproc.getData_API(api, 'products')
del products_data['videoChapters']
del products_data['videoLanguages']... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def single_review_prep(text):\n clean_test = data_cleaner(text)\n dummy_dict= {'star': [clean_test]}\n clean_test_df = pd.DataFrame(dummy_dict)\n return clean_test_df",
"def preprocess_data(df, min_vote_count=1000):\n # note that order matters!\n df = remove_rows_without_feature(df, 'budget')\n... | [
"0.6396756",
"0.59188193",
"0.58962667",
"0.5809514",
"0.5796008",
"0.5783609",
"0.5739264",
"0.5638419",
"0.56384134",
"0.56228554",
"0.56181115",
"0.55560744",
"0.551565",
"0.54739445",
"0.54389805",
"0.5433427",
"0.5418286",
"0.5389239",
"0.53320706",
"0.53245866",
"0.5295... | 0.0 | -1 |
uses the USA Today API in order to extract the list of the subAPIs for music reviews | def obtain_USAToday_APIs(api="http://api.usatoday.com/open/reviews/music?count=1000&api_key=mhph6f4afgvetbqtex4rs22a"):
import requests
r = requests.get(api)
jsonfile = r.json()
key = jsonfile.keys()
data = jsonfile[key[0]]
keys = jsonfile[key[0]].keys()
api_dict = {}
nData =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, request, format=None):\n albums = MusicAlbum.objects.all()\n # trending = \n # popular = albums[6:]\n recommendations = serializers.ReadMusicAlbumSerializer(\n albums[:2], many=True, context={'request': request}\n )\n trending = serializers.ReadMus... | [
"0.5990308",
"0.5970837",
"0.576632",
"0.5740902",
"0.5699372",
"0.5680496",
"0.5655822",
"0.55319315",
"0.5443329",
"0.54422873",
"0.5438654",
"0.5432013",
"0.5431028",
"0.5429935",
"0.54219544",
"0.5420579",
"0.54025465",
"0.5399872",
"0.5391939",
"0.5383238",
"0.5366309",
... | 0.66950834 | 0 |
convert any item to a numpy ndarray | def to_ndarray(item):
return type(item), sp.array(item, sp.float64, ndmin=1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _to_ndarray(data):\n return np.atleast_1d(getattr(data, 'values', data))",
"def convert_to_ndarray(entity):\n if isinstance(entity, np.ndarray) and entity.dtype.kind in set('biufc'):\n # entity is numerical ndarray already\n return entity\n if isinstance(entity, np.ndarray) and isinsta... | [
"0.7383202",
"0.712074",
"0.70498645",
"0.70083153",
"0.69416726",
"0.69294995",
"0.6854728",
"0.6834907",
"0.6817344",
"0.6804671",
"0.6770331",
"0.66576916",
"0.6650874",
"0.6647591",
"0.6646724",
"0.6613207",
"0.6582173",
"0.6582173",
"0.65404516",
"0.6507793",
"0.64623237... | 0.7740508 | 0 |
convert any numpy array back to its original item type | def from_ndarray(itemtype, *items):
if itemtype in [IntType, LongType, FloatType]:
val = tuple(i.flat[0] for i in items)
elif itemtype is ListType:
val = tuple(i.tolist() for i in items)
elif itemtype is TupleType:
val = tuple(tuple(i.tolist()) for i in items)
elif itemtype is s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convert_data(self, data):\n if isinstance(data, Tensor):\n data = data.asnumpy()\n elif isinstance(data, list):\n data = np.array(data)\n elif isinstance(data, np.ndarray):\n pass\n else:\n raise TypeError('Input data type must be tensor,... | [
"0.6909233",
"0.6677645",
"0.65852803",
"0.6516039",
"0.6478485",
"0.64684",
"0.64437616",
"0.63853025",
"0.6327636",
"0.632323",
"0.62723",
"0.62629884",
"0.61994326",
"0.6190795",
"0.61809444",
"0.61559033",
"0.61377347",
"0.610936",
"0.6108303",
"0.6102446",
"0.6083558",
... | 0.598934 | 30 |
Compute the ROUGEN score of a peer with respect to one or more models, for a given value of `n`. | def rouge_n(peer, models, n, alpha=1):
matches = 0
recall_total = 0
peer_counter = _ngram_counts(peer, n)
for model in models:
model_counter = _ngram_counts(model, n)
matches += _counter_overlap(peer_counter, model_counter)
recall_total += _ngram_count(model, n)
precision_tot... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_score(self, n_episodes=5):\n\n # Score is computed via aggregate over multiple episodes\n score = 0\n\n for _ in range(n_episodes):\n score += play_episode(self.model, self.env)\n\n return score / n_episodes",
"def compute_rouge_n(output, reference, n=1, mode='f... | [
"0.6221026",
"0.61857086",
"0.59200484",
"0.5913296",
"0.58413684",
"0.58119303",
"0.5691505",
"0.56906444",
"0.5665036",
"0.5646627",
"0.5615947",
"0.5566597",
"0.55650103",
"0.55646986",
"0.55566496",
"0.5514124",
"0.5488513",
"0.5460889",
"0.545565",
"0.54523516",
"0.54460... | 0.7420437 | 0 |
Compute the ROUGE1 (unigram) score of a peer with respect to one or more models. | def rouge_1(peer, models, alpha=1):
return rouge_n(peer, models, 1, alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rouge_l(peer, models, alpha=1):\n matches = 0\n recall_total = 0\n for model in models:\n matches += lcs(model, peer)\n recall_total += len(model)\n precision_total = len(models) * len(peer)\n return _safe_f1(matches, recall_total, precision_total, alpha)",
"def rouge_2(peer, mod... | [
"0.6404512",
"0.6164474",
"0.61226386",
"0.57171863",
"0.56591094",
"0.56569135",
"0.5644448",
"0.5607102",
"0.5510303",
"0.5491259",
"0.5481637",
"0.547529",
"0.54537225",
"0.5388831",
"0.52865225",
"0.52846694",
"0.52558506",
"0.52415675",
"0.52409685",
"0.5237391",
"0.5225... | 0.69222933 | 0 |
Compute the ROUGE2 (bigram) score of a peer with respect to one or more models. | def rouge_2(peer, models, alpha=1):
return rouge_n(peer, models, 2, alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rouge_n(peer, models, n, alpha=1):\n matches = 0\n recall_total = 0\n peer_counter = _ngram_counts(peer, n)\n for model in models:\n model_counter = _ngram_counts(model, n)\n matches += _counter_overlap(peer_counter, model_counter)\n recall_total += _ngram_count(model, n)\n ... | [
"0.63647765",
"0.6264367",
"0.6048327",
"0.56891185",
"0.559623",
"0.5595172",
"0.55653435",
"0.5532778",
"0.5503071",
"0.5493627",
"0.54738057",
"0.54648376",
"0.5429727",
"0.54142624",
"0.5363083",
"0.53563017",
"0.53514856",
"0.53496987",
"0.5347989",
"0.53299314",
"0.5326... | 0.68937504 | 0 |
Compute the ROUGE3 (trigram) score of a peer with respect to one or more models. | def rouge_3(peer, models, alpha=1):
return rouge_n(peer, models, 3, alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rouge_l(peer, models, alpha=1):\n matches = 0\n recall_total = 0\n for model in models:\n matches += lcs(model, peer)\n recall_total += len(model)\n precision_total = len(models) * len(peer)\n return _safe_f1(matches, recall_total, precision_total, alpha)",
"def rouge_n(peer, mod... | [
"0.6201271",
"0.59838575",
"0.56443214",
"0.563465",
"0.5621777",
"0.56136626",
"0.5591619",
"0.551658",
"0.5460007",
"0.5452518",
"0.54252064",
"0.5394155",
"0.53527737",
"0.5327824",
"0.531235",
"0.5268596",
"0.5262611",
"0.5215765",
"0.5202057",
"0.518789",
"0.518238",
"... | 0.6721017 | 0 |
Compute the length of the longest common subsequence between two sequences. | def lcs(a, b):
# This is an adaptation of the standard LCS dynamic programming algorithm
# tweaked for lower memory consumption.
# Sequence a is laid out along the rows, b along the columns.
# Minimize number of columns to minimize required memory
if len(a) < len(b):
a, b = b, a
# Sequen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n if len(text1) == 0 or len(text2) == 0:\n return 0\n if text1[0] == text2[0]:\n return 1 + self.longestCommonSubsequence(text1[1:], text2[1:])\n else:\n return max(self.longestCommonSubsequence... | [
"0.80766463",
"0.77502847",
"0.7713622",
"0.7646066",
"0.7540484",
"0.7536629",
"0.72903633",
"0.717842",
"0.71512765",
"0.7116953",
"0.70604825",
"0.6989596",
"0.6979806",
"0.6972248",
"0.69665587",
"0.6891922",
"0.6855986",
"0.68384045",
"0.68181574",
"0.6776346",
"0.675722... | 0.6458489 | 44 |
Compute the ROUGEL score of a peer with respect to one or more models. | def rouge_l(peer, models, alpha=1):
matches = 0
recall_total = 0
for model in models:
matches += lcs(model, peer)
recall_total += len(model)
precision_total = len(models) * len(peer)
return _safe_f1(matches, recall_total, precision_total, alpha) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def score(self, params):\n\n if self.use_sqrt:\n return self.score_sqrt(params)\n else:\n return self.score_full(params)",
"def score(self, model, probe):\n return scipy.spatial.distance.euclidean(model, probe)",
"def rouge_1(peer, models, alpha=1):\n return rouge_n(pe... | [
"0.64376223",
"0.61849993",
"0.6173057",
"0.6096087",
"0.6008323",
"0.5948405",
"0.59441435",
"0.5903325",
"0.5891097",
"0.5812651",
"0.5770408",
"0.5759025",
"0.573958",
"0.5702037",
"0.5636004",
"0.5603585",
"0.55869937",
"0.5549397",
"0.5543058",
"0.5512206",
"0.5507263",
... | 0.6972612 | 0 |
This function actually applies the translation table to the data. | def translate(table, data, compress=True):
out=data
point=START_CHR
for conv in table:
out=out.replace(*((conv, chr(point)) if compress else (chr(point), conv)))
point+=1
return out | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def translate(self):\n self.clean_data()\n self.clean_symbols()\n self.translate_line_by_line()",
"def apply_translation(self, translation_table, fromcolumn=None,\n tocolumn=None, clipvalue=65535.0 ):\n translation_table = np.asarray(translation_table)\n ... | [
"0.6654487",
"0.6397048",
"0.63600653",
"0.63000005",
"0.6274757",
"0.6105659",
"0.60185516",
"0.6017183",
"0.6017183",
"0.5999535",
"0.5927593",
"0.5778712",
"0.57606953",
"0.5715766",
"0.56984544",
"0.5659792",
"0.56475574",
"0.5623773",
"0.56182456",
"0.5615333",
"0.561191... | 0.6044234 | 6 |
Runs the python code on the data (either preprocessing or postprocessing). | def process_python(data, code):
x=data
return eval(code) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, data):\n\t\t# no processing here\n\t\treturn data",
"def main():\n p = DataPreprocessor()\n p.preprocess_and_save_data(p.path_to_file)",
"def run_data (arguments):\n if arguments.define_labels:\n data.define_labels()\n elif arguments.preprocess:\n # Preprocess from data_raw --> data... | [
"0.6739296",
"0.66835475",
"0.6407259",
"0.6377818",
"0.63762534",
"0.6327601",
"0.62914467",
"0.62914467",
"0.6246008",
"0.62302923",
"0.6209348",
"0.61613804",
"0.6066117",
"0.60660374",
"0.60589004",
"0.6053382",
"0.60187465",
"0.60002595",
"0.59653044",
"0.59533066",
"0.5... | 0.6572977 | 2 |
Given a list of graphs in networkx format, write each of them in its own little gml file in a folder named name in the data_root folder. Create the folder, if necessary. This function is very hacky, parsing node labels on the go for datasets obtained from the Dortmund collection at | def write_graph_list(name, graph_list, data_root):
data_path = os.path.join(data_root, name)
if not os.path.exists(data_path):
os.makedirs(data_path)
# compute right number of trailing zeros for file names
format_positions = ceil(log10(len(graph_list)))
for i, g in enumerate(graph_list):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _create_layout(root_dir, subsets):\n _create_folder(os.path.join(root_dir, \"images\"))\n _create_folder(os.path.join(root_dir, \"labels\"))\n\n for subset in subsets:\n _create_folder(os.path.join(root_dir, \"images\", subset))\n _create_folder(os.path.join(root_dir, \"labels\", subset)... | [
"0.6296529",
"0.6196926",
"0.6115122",
"0.60457796",
"0.60432667",
"0.6025473",
"0.6017168",
"0.6001553",
"0.5972465",
"0.5906791",
"0.5901544",
"0.585161",
"0.58406854",
"0.5752646",
"0.5749147",
"0.57461995",
"0.5728297",
"0.5697866",
"0.5691245",
"0.56871533",
"0.5682423",... | 0.77036434 | 0 |
Very very hacky. Works for BZR and DHFR to remove attributes and make labels compliant. | def dumpLabel(g):
for v in g.nodes():
g.node[v]['label'] = getLabel(g.node[v])
if 'attribute' in g.node[v]:
del g.node[v]['attribute']
for e in g.edges():
g.edge[e[0]][e[1]]['label'] = getLabel(g.edge[e[0]][e[1]])
if 'attribute' in g.edge[e[0]][e[1]]:
del... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strip_useless_attributes(self):\n graph_dict = self.graph.graph\n if \"node\" in graph_dict and \"label\" in graph_dict[\"node\"]:\n graph_dict[\"node\"].pop(\"label\")\n if \"graph\" in graph_dict:\n graph_dict.pop(\"graph\")",
"def remove_label(self, ):\n i... | [
"0.6855171",
"0.67771274",
"0.63467556",
"0.63325405",
"0.6005318",
"0.5989882",
"0.59445316",
"0.59248656",
"0.5919599",
"0.59110916",
"0.5872996",
"0.5867377",
"0.5824793",
"0.5820824",
"0.5725552",
"0.57142097",
"0.5713263",
"0.565817",
"0.5647423",
"0.56366366",
"0.562795... | 0.5637095 | 19 |
print a main menu and the commands | def showInstructions():
print("""
RPG Game
========
Commands:
go [direction]
get [item]
""") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def printMenu():\n # tWelc = PrettyTable(['Welcome to the CLI-of the repository classifier'])\n print('Welcome to the CLI of the repository classifier')\n print(strStopper1)\n t = PrettyTable(['Action', ' Shortcut '])\n t.add_row(['Show Menu', '- m -'])\n t.add_row([' Predict repositori... | [
"0.85980755",
"0.82323325",
"0.8142767",
"0.813813",
"0.8126603",
"0.81215715",
"0.7886918",
"0.78196526",
"0.7761626",
"0.772209",
"0.7706884",
"0.762542",
"0.761819",
"0.7607258",
"0.7597612",
"0.7591094",
"0.75864893",
"0.7538107",
"0.751255",
"0.7507642",
"0.7492476",
"... | 0.65656286 | 66 |
fetches tweets and wraps them in Tweet objects | def get_tweets(self):
now = datetime.datetime.now()
tweet_json = self.api.get_tweets(self.last, now)
self.last = now
return [Tweet(x) for x in tweet_json] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tweets():\n clean_tweetdb.delay()\n db_tweets = Tweet.objects.all()\n max_id = min([tweet.tweet_id for tweet in db_tweets])\n tweets = api.search(\n q='#python',\n max_id=max_id,\n count=100\n )\n tweets_id = [tweet.id for tweet in tweets]\n tweets_date = [tweet.cr... | [
"0.76285994",
"0.7314002",
"0.72527397",
"0.7232973",
"0.7203812",
"0.72006255",
"0.71095735",
"0.7069534",
"0.70468444",
"0.70431787",
"0.70248395",
"0.70181644",
"0.70125926",
"0.70005286",
"0.69737434",
"0.69352496",
"0.6934322",
"0.68964857",
"0.688853",
"0.68642783",
"0.... | 0.73902327 | 1 |
constructor for Tweet class | def __init__(self, tweet_json):
self.tweet = tweet_json
self.date = datetime.datetime.strptime(self.tweet["date"], "%Y-%m-%dT%H:%M:%S.000Z")
self.processed = False
self.max_importance = 0
try:
text = re.sub(self.tweet["keywords"][0], '', self.tweet["text"])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, id_: str, bio: str) -> None:\n\n # YOUR CODE HERE\n self.userid = id_\n self.bio = bio\n self.tweets = []",
"def __init__(self):\n self.tweets = {}\n self.followees = {}\n self.timestamp = 0",
"def __init__(self, tweet_data):\n _hashtag... | [
"0.73487216",
"0.70724875",
"0.7051352",
"0.70227826",
"0.69214594",
"0.6850634",
"0.6793486",
"0.6756056",
"0.6675334",
"0.66327745",
"0.66132927",
"0.66100866",
"0.65269214",
"0.6500472",
"0.6484132",
"0.6462133",
"0.64041936",
"0.6386881",
"0.6380593",
"0.6349382",
"0.6297... | 0.6826531 | 6 |
get language of tweet according to polyglot | def get_language(self):
return self.language | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_translated_tweet(tweet, language='it'):\n translated = GoogleTranslator(source='auto', target=language)\n return translated.translate(tweet)",
"def get_language(self, text):\n try:\n post_lang = detect(text)\n except:\n post_lang = 'N/A'\n return post_lang... | [
"0.72462946",
"0.7083339",
"0.6802315",
"0.6707334",
"0.6658513",
"0.66378605",
"0.65683573",
"0.6546926",
"0.65229803",
"0.65075666",
"0.64140195",
"0.6395052",
"0.6386839",
"0.63669634",
"0.63650763",
"0.6354169",
"0.6340496",
"0.63091576",
"0.62775445",
"0.6255256",
"0.621... | 0.6484868 | 10 |
updates max_importance value if importance is higher then max_importance | def update_importance(self, importance):
if importance > self.max_importance:
self.max_importance = importance | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_importance(self, importance):\r\n self.importance = importance\r\n for tweet in self.tweets:\r\n tweet.update_importance(importance)",
"def change_max(self, level, value):\n if value < 0:\n raise AttributeError('max value should be greater than zero')\n i... | [
"0.6120561",
"0.5990391",
"0.56675154",
"0.56649125",
"0.5598316",
"0.5463613",
"0.5463613",
"0.5452502",
"0.541491",
"0.5413382",
"0.5384408",
"0.5384408",
"0.53646934",
"0.53610283",
"0.53610283",
"0.53610283",
"0.5323976",
"0.53171647",
"0.5316251",
"0.5280184",
"0.5269162... | 0.86922395 | 0 |
constructor for the AbstractAPI | def __init__(self, region):
self.region = region | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, base_api: BaseApi):\n super().__init__(base_api, self.__class__.__name__)",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n r... | [
"0.80145794",
"0.78466344",
"0.78466344",
"0.78466344",
"0.78466344",
"0.78052104",
"0.7794079",
"0.77604795",
"0.773415",
"0.77304065",
"0.7708006",
"0.7698352",
"0.762925",
"0.76172245",
"0.76172245",
"0.7611515",
"0.7587762",
"0.75137764",
"0.74682426",
"0.7432127",
"0.743... | 0.0 | -1 |
fetches tweets from start date till end date | def get_tweets(self, start_date, end_date):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tweets(self, start_date, end_date):\r\n # get tweets from api\r\n config = crawler.APIConfig()\r\n config.set_api_key(\"8e1618e9-419f-4239-a2ee-c0680740a500\")\r\n config.set_end_time(end_date)\r\n config.set_filter(self.region)\r\n config.set_start_time(start_date... | [
"0.7896825",
"0.76824534",
"0.7510762",
"0.7041128",
"0.6890227",
"0.6792959",
"0.6664002",
"0.66307527",
"0.65022916",
"0.6492793",
"0.64922196",
"0.6477469",
"0.6452656",
"0.6447653",
"0.6434829",
"0.6408373",
"0.6390277",
"0.63862234",
"0.6347076",
"0.6342707",
"0.6322864"... | 0.8704661 | 0 |
fetches tweets from start date till end date | def get_tweets(self, start_date, end_date):
# get tweets from api
config = crawler.APIConfig()
config.set_api_key("8e1618e9-419f-4239-a2ee-c0680740a500")
config.set_end_time(end_date)
config.set_filter(self.region)
config.set_start_time(start_date)
return c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tweets(self, start_date, end_date):\r\n pass",
"def getTweets(self, query, start, end):\n gettweets = Twitter.GetTweets(self.rootpath, self.folderpath,\n start, end, query)\n gettweets.start_getTweets()",
"def get_tweets_in_date_range(start, end... | [
"0.8704661",
"0.76824534",
"0.7510762",
"0.7041128",
"0.6890227",
"0.6792959",
"0.6664002",
"0.66307527",
"0.65022916",
"0.6492793",
"0.64922196",
"0.6477469",
"0.6452656",
"0.6447653",
"0.6434829",
"0.6408373",
"0.6390277",
"0.63862234",
"0.6347076",
"0.6342707",
"0.6322864"... | 0.7896825 | 1 |
Get Seconds from time. | def get_sec(time_str):
h, m, s = time_str.split(':')
return int(h) * 3600 + int(m) * 60 + int(s) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_seconds(time):\n return 3600 * time",
"def time_to_int(self):\n minutes = self.hour * 60 + self.minute\n seconds = minutes * 60 + self.second\n return seconds",
"def time_to_int(time):\n minutes = time.hour * 60 + time.minute\n seconds = minutes * 60 + time.second\n retu... | [
"0.78827816",
"0.7511598",
"0.74796194",
"0.73971415",
"0.7275454",
"0.7262169",
"0.718104",
"0.71555495",
"0.7036447",
"0.69965965",
"0.6980901",
"0.6879055",
"0.6844431",
"0.6838192",
"0.6817343",
"0.67910403",
"0.67888385",
"0.6770099",
"0.67639846",
"0.67639846",
"0.67117... | 0.70772296 | 9 |
Check the give word is palindrome. | def isPalindrome(word):
input_str = IGNORE_NON_ALPHA_CHARACTER.sub("", str(word)).casefold()
return input_str == input_str[::-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def palindrome(word):\n reverse = word[::-1]\n return word == reverse",
"def is_palindrome(word):\n if word == word[::-1]:\n return True\n else:\n return False",
"def is_palindrome(word: str) -> bool:\n\n # Todo\n return False",
"def check_palindrome():",
"def string_palidro... | [
"0.89213616",
"0.8837968",
"0.8779761",
"0.87497747",
"0.86763763",
"0.85616016",
"0.83406484",
"0.83270764",
"0.8197752",
"0.8196361",
"0.8171091",
"0.8113323",
"0.8112018",
"0.8089886",
"0.80283785",
"0.80139244",
"0.79979086",
"0.79918855",
"0.7983047",
"0.79630023",
"0.79... | 0.8555572 | 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.