def webhooks():
try:
data = json.loads(request.data)
keen.add_event('gh', data)
return "OK"
except Exception, e:
print e
def test_alignment_count(applet_id, project_id, folder, tmpdir):
"""Run BWA on a FASTQ file and verify that the number of
alignments produced is correct.
"""
# Recall that applet_id is set in the associated conftest.py, which either
# gets it from the command line or builds the applet and retrieves its id.
# And tmpdir is some pytest magic. It's type is py.path.local.LocalPath.
# It's strpath property just returns a string.
applet = dxpy.DXApplet(applet_id)
input_dict = {"fastq": dxpy.dxlink(SAMPLE_FASTQ),
"genomeindex_targz": dxpy.dxlink(HS37D5_BWA_INDEX)}
start_time = time.time()
job = applet.run(input_dict, instance_type="mem1_ssd1_x16",
folder=folder, project=project_id)
job.wait_on_done()
end_time = time.time()
elapsed_time = end_time - start_time
output_bam_dxfile = dxpy.DXFile(job.describe()["output"]["bam"])
local_filename = os.path.join(tmpdir.strpath, "test.bam")
dxpy.download_dxfile(output_bam_dxfile.get_id(),
local_filename)
count_alignments_cmd = "samtools view {bam} | wc -l".format(
bam=local_filename)
num_alignments = int(subprocess.check_output(count_alignments_cmd,
shell=True))
keen.add_event("applet1_tests", {"num_alignments": num_alignments,
"running_time": elapsed_time})
assert job.describe()['state'] == 'done'
def get_queryset(self):
from apps.events.api.views import EventViewSet
queryset = EventViewSet.get_direct_queryset(self.request)
# Apply any location filters if needed
if self.bounds:
queryset = queryset.filter(venue__point__within=self.bounds).distance(
self.bounds.centroid, field_name="venue__point"
)
self.location_available = True
try:
keen.add_event(
"event_filter",
{
"keen": {"location": {"coordinates": [self.bounds.centroid.x, self.bounds.centroid.y]}},
"category": self.category_slug,
},
timezone.now(),
)
except keen.InvalidEnvironmentError:
pass
if self.category_slug:
queryset = queryset.filter(category__slug=self.category_slug)
try:
self.category = Category.objects.get(slug=self.category_slug)
except Category.DoesNotExist:
pass
self.queryset = queryset
return super(Events, self).get_queryset()
def test_module_level_add_event(self):
keen.project_id = "5004ded1163d66114f000000"
api_key = "2e79c6ec1d0145be8891bf668599c79a"
keen.write_key = scoped_keys.encrypt(api_key,
{"allowed_operations": ["write"]})
# client = KeenClient(project_id, write_key=write_key, read_key=read_key)
keen.add_event("python_test", {"hello": "goodbye"})
def signin():
if request.method == 'POST':
name = request.form.get('name')
pw = request.form.get('pw')
if name and pw:
if len(name) > 0 and len(pw) > 0:
name_is_alphanum = model.check_alphanum(name)
pw_is_alphanum = model.check_alphanum(pw)
if name_is_alphanum == True and pw_is_alphanum == True:
if model.auth_login(name, pw) == True:
keen.add_event('signins', {"username": name})
session['user'] = name
return redirect(url_for('index'))
else:
flash(
'Your user name and/or password didn\'t match our records. Please try signing in again.'
)
return render_template('signin.html')
else:
flash(
'Your user name and/or password didn\'t match our records. Please try signing in again.'
)
return render_template('signin.html')
elif not session:
return render_template('signin.html')
else:
# if there's a session
flash('You\'re already signed in.')
return redirect(url_for('index'))
def main():
keen.project_id = "<insert-your-credentials-here"
keen.write_key = "<insert-your-credentials-here"
keen.read_key = "<insert-your-credentials-here"
keen.master_key = "<insert-your-credentials-here"
with open('LoanStats3d.csv') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
x = 0
for row in reader:
if (len(row) == 52):
for x in range(0, len(row)):
if (isint(row[x])):
row[x] = int(row[x])
elif (isfloat(row[x])):
row[x] = float(row[x])
try: #specific data that needs small manipulation to record
row[6] = float(row[6][0:-1])
row[33] = float(row[33][0:-1])
except:
pass
data_rows.append(row)
columns = data_rows.pop(
0) #pop first row, which are the name of the columns
loanee = {}
for x in range(0, 1000):
loanee = dict(zip(columns, data_rows[x]))
#print(loanee["term"])
keen.add_event("Loanee", loanee)
print("Event #" + str(x) + " loaded")
def log(cls, event_type, user, object=None, **kwargs):
if METRICS:
obj = cls()
obj.type_id = event_type if isinstance(event_type, int) else EventType.get(event_type)
obj.user = user
if object:
obj.object = object
obj.save()
keen_keys = SystemKey().get_keys("Keen API")
keen.project_id = keen_keys["KEEN_PROJECT_ID"]
keen.write_key = keen_keys["KEEN_WRITE_KEY"]
keen.read_key = keen_keys["KEEN_READ_KEY"]
try:
if object:
keen.add_event(
event_type,
{
"object_name": object.__str__().decode("utf-8"),
"object_id": object.id if object else "",
"user": user.get_full_name() if user else "",
"user_id": user.id if user else "",
},
)
else:
keen.add_event(
event_type, {"user": user.get_full_name() if user else "", "user_id": user.id if user else ""}
)
except (BaseKeenClientError, ConnectionError):
logger.exception("Error occurred when logging an event to Keen")
return obj
def main():
keen.project_id = "<insert-your-credentials-here"
keen.write_key = "<insert-your-credentials-here"
keen.read_key = "<insert-your-credentials-here"
keen.master_key = "<insert-your-credentials-here"
with open ('LoanStats3d.csv') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
x = 0
for row in reader:
if (len(row) == 52):
for x in range(0,len(row)):
if (isint(row[x])):
row[x] = int(row[x])
elif (isfloat(row[x])):
row[x] = float(row[x])
try: #specific data that needs small manipulation to record
row[6] = float(row[6][0:-1])
row[33] = float(row[33][0:-1])
except:
pass
data_rows.append(row)
columns = data_rows.pop(0) #pop first row, which are the name of the columns
loanee = {};
for x in range(0,1000):
loanee = dict(zip(columns, data_rows[x]))
#print(loanee["term"])
keen.add_event("Loanee", loanee)
print("Event #" + str(x) + " loaded")
def signin():
if request.method =='POST':
name = request.form.get('name')
pw = request.form.get('pw')
if name and pw:
if len(name) > 0 and len(pw) > 0:
name_is_alphanum = model.check_alphanum(name)
pw_is_alphanum = model.check_alphanum(pw)
if name_is_alphanum == True and pw_is_alphanum == True:
if model.auth_login(name, pw) == True:
keen.add_event('signins', {
"username":name
})
session['user'] = name
return redirect(url_for('index'))
else:
flash('Your user name and/or password didn\'t match our records. Please try signing in again.')
return render_template('signin.html')
else:
flash('Your user name and/or password didn\'t match our records. Please try signing in again.')
return render_template('signin.html')
elif not session:
return render_template('signin.html')
else:
# if there's a session
flash('You\'re already signed in.')
return redirect(url_for('index'))
def on_message(client, userdata, msg):
_data = userdata[msg.topic]
if 'last update' in _data:
diff = time.time() - _data['last update']
if diff < _data['update period']:
#print("Skipping {} due to update frequency {}".format(
# msg.topic, diff))
return
_data['last update'] = time.time()
_offset = _data.get('time offset', 0)
_timestamp = struct.unpack('>I', msg.payload[0:4])[0]
_meas = struct.unpack('>i', msg.payload[4:8])[0]
if 'factor' in _data:
_meas = float(_meas) / _data['factor']
print('Topic {} has value {} at timestamp {}'.format(
msg.topic, _meas, hex(_timestamp)))
event = dict()
event['keen'] = {
'timestamp':
datetime.datetime.utcfromtimestamp(_timestamp + _offset).isoformat()
}
event[_data['ev_name']] = _meas
print(event)
keen.add_event(_data['ev_collection'], event)
def history_text(user_id, page: int) -> str:
user = get_user(user_id, 'ins')
if isinstance(user, str):
raise Exception(user)
message_list = []
try:
history_response = api.messages.getHistory(user_id=user['id'],
offset=page * 20)['items']
except exceptions.VkException as e:
raise e
for i in history_response:
message_body = i['body']
if len(message_body) > 120:
message_body = message_body[:120]
if i['out'] == 0:
message_list.append({'>>> ': message_body})
else:
message_list.append({'<<< ': message_body})
text_form = 'Сообщения с <b>' + user['first_name'] + ' ' + user[
'last_name'] + '</b>(' + str(page) + ')\n'
for item in message_list:
for k, v in item.items():
text_form = text_form + '\n' + k + utils.escapize(v)
user_nom = get_user(user)
if isinstance(user_nom, str):
raise Exception(user_nom)
nom_name = user_nom['first_name'] + ' ' + user_nom['last_name']
utils.dbadd('activity', '📃️ ' + nom_name + ' - ' + str(user_nom['id']))
keen.add_event("history", {"to_user": user_nom['id']})
return text_form
def button(bot, update):
query = update.callback_query
bl = utils.dbget('button')
if bl is not None:
if str(query.from_user.id) in bl:
return
user_id, page = query.data.split('|')
try:
keyboard = [
InlineKeyboardButton("<",
callback_data=user_id + '|' +
str(int(page) - 1)),
InlineKeyboardButton(">",
callback_data=user_id + '|' +
str(int(page) + 1))
]
if int(page) == 0:
keyboard.pop(0)
reply_markup = InlineKeyboardMarkup([keyboard])
msg = history_text(user_id, int(page))
bot.editMessageText(chat_id=query.message.chat_id,
text=msg,
parse_mode='HTML',
reply_markup=reply_markup,
message_id=query.message.message_id)
keen.add_event("history_button", {"req_user": user_id})
except Exception:
return
def sethook(bot, update, cmd=None):
if not cmd:
return
blacklist = utils.dbget('hook')
if blacklist is not None:
if str(update.message.from_user.id) in blacklist:
update.message.reply_text(
emojize(choice(utils.blacklist_strings), use_aliases=True))
return
check_black = utils.dbget('notarget')
hook_vk_user = get_user(cmd[0])
if isinstance(hook_vk_user, str):
update.message.reply_text(
emojize('Ошибка :disappointed:', use_aliases=True))
return
reply_text = emojize('Хорошо :ok_hand:', use_aliases=True)
if check_black is not None:
if str(hook_vk_user['id']) in check_black:
reply_text = hook_vk_user['first_name'] + ' ' + hook_vk_user[
'last_name'] + ' помечен как спамер!\nЕсли этот человек будет спамить вам, вы можете ввести /delhook ' + str(
hook_vk_user['id']
) + ' чтобы перестать получать от него сообшения'
utils.dbadd(hook_vk_user['id'], update.message.chat.id)
update.message.reply_text(reply_text)
keen.add_event("set_hook", {
"by_user": update.message.from_user.id,
"req_user": cmd[0]
})
def longpoll_call():
global poll
response = poll.get()
if response is None:
poll = longpoll_init()
sleep(1)
return
if not response:
return
# Main
for box in response:
if box[0] == 4:
print(box)
message_id = box[1]
message_object = api.messages.getById(message_ids=message_id)
if message_object['items'][0]['out'] == 1:
continue
keen.add_event(
"received",
{"user_id": str(message_object['items'][0]['user_id'])})
# mark as read
try:
api.messages.markAsRead(message_ids=message_id)
except exceptions.VkException:
print('mark as read error')
# end
pprint(message_object)
parse_message(message_object['items'][0], poll_callback)
def monitor():
cloud = heroku.from_key(os.getenv("HEROKU_API_KEY"))
app_name = os.getenv("MONITOR_APP_NAME")
app = cloud.apps[app_name]
dynos = app.processes["web"]
logs = app.logs(num=1000, ps="web").splitlines()
logs.reverse()
memory_error_logs = []
for log in logs:
if "Error R14" in log:
memory_error_logs.append(log)
if os.getenv("DYNO_MONITOR_DEBUG"):
keen.add_event("dyno_monitor_debug", {
"app": app_name,
})
i = 1
for dyno in dynos:
try:
dyno_response = next(x for x in memory_error_logs if "web.%s" % i in x)
if dyno_response:
dynos[i-1].restart()
keen.add_event("dyno_restart", {
"app": app_name,
"dyno": "web.%s" % i,
})
except StopIteration:
pass
i += 1
def game():
if not session:
return render_template('login_tt.html')
if session['user']:
game_info = model.get_words_tweets_game()
word_for_game = game_info[0]
tweet_for_game = game_info[1]
tweet_list = game_info[2]
user = session['user']
user_name_pts = "user_%s_pts"%user
user_points = model.get_string_num(user_name_pts)
tweet_for_game = unicode(tweet_for_game, 'utf-8', errors='replace')
for tweet in tweet_list:
tweet = unicode(tweet, 'utf-8', errors='replace')
pos_sents_tags = model.break_pos_sents(model.get_pos_sentences())
first_half = pos_sents_tags[:len(pos_sents_tags)/2]
second_half = pos_sents_tags[len(pos_sents_tags)/2:]
logged_in = 'Logged in as: %s.'%user
not_you = 'Not %s?'%session['user']
num_tagged = model.get_num_tagged(user)
num_final_tagged = model.get_num_final_tagged(user)
keen.add_event('game_play', {
"user":user,
"points":user_points,
"num_tagged":num_tagged,
"num_final_tagged":num_final_tagged
})
return render_template('game.html', word = word_for_game, tweet = Markup(tweet_for_game).unescape(), user_points=user_points, tweet_list=tweet_list, first_half=first_half, second_half=second_half, logged_in=logged_in, user=user, not_you=not_you)
def new_tweet():
word = request.form.get('word')
tweet = request.form.get('tweet')
user = session['user']
user_name_pts = "user_%s_pts"%user
points = model.get_string_num(user_name_pts)
num_tagged = model.get_num_tagged(user)
num_final_tagged = model.get_num_final_tagged(user)
keen.add_event('more_tweets', {
"user":user,
'word':word,
'original tweet':tweet,
'num_tagged':num_tagged,
'num_final_tagged':num_final_tagged,
'points':points
})
tweet_list = model.get_another_tweet(word, tweet)
tweets_gotten = request.form.get('tweets_gotten')
if tweets_gotten > 0:
if len(tweet_list) >= tweets_gotten:
new_tweet = tweet_list[-tweets_gotten]
if new_tweet == tweet:
return "There are no more tweets with \"%s\" in them."%word
else:
new_tweet = unicode(new_tweet, 'utf-8', errors='replace')
return render_template('moretweets.html', tweet=Markup(new_tweet).unescape())
else:
new_tweet = "There are no more tweets with \"%s\" in them."%word
return render_template('moretweets.html', tweet=new_tweet)
else:
new_tweet = "There are no more tweets with \"%s\" in them."%word
return render_template('moretweets.html', tweet=new_tweet)
def add_event(collection, user: User, body: Dict = None):
if user.is_staff:
logger.debug('Skipping staff user event')
return
if user.email in settings.TEST_EMAIL_ADDRESSES:
logger.debug('Skipping test user event')
return
for domain in settings.TEST_EMAIL_DOMAINS:
if user.email.endswith(domain):
logger.debug('Skipping test user event')
return
if body is None:
body = {}
body['user_id'] = user.id
body['email'] = user.email
if settings.DEBUG:
events.append({'collection': collection, 'body': body})
else:
logger.debug('Recording %s event %s' % (collection, str(body)))
keen.add_event(collection, body)
def play_game():
tag = request.form.get('tag')
word = request.form.get('word')
tweet = request.form.get('tweet')
user = session['user']
num_tagged = model.get_num_tagged(user)
num_final_tagged = model.get_num_final_tagged(user)
if tag and word:
# set the tag for the user and the tweet
model.tag_word_game(word, tag, user, tweet)
# add points and set final tag if needed
model.add_pts_game(word, tag, user)
# retrieve how many points user has
user_name_pts = "user_%s_pts" % user
num_points = model.get_string_num(user_name_pts)
keen.add_event(
"button_press", {
"tag": tag,
"word": word,
"user": user,
"num_tagged": num_tagged,
"num_final_tagged": num_final_tagged,
"points": num_points
})
return str(num_points)
def action():
#Adding a Task
name = request.values.get("name")
desc = request.values.get("desc")
date = request.values.get("date")
pr = request.values.get("pr")
_id = todos.insert({
"name": name,
"desc": desc,
"date": date,
"pr": pr,
"done": "no"
})
print("Sanity Check {0}".format(_id))
# Add Keen to collect the event and persist a User ID
keen.add_event(
"helpdesk_task", {
"name": name,
"desc": desc,
"date": date,
"pr": pr,
"user_identity": "{0}".format(_id)
})
return redirect("/list")
def new_tweet():
word = request.form.get('word')
tweet = request.form.get('tweet')
user = session['user']
user_name_pts = "user_%s_pts" % user
points = model.get_string_num(user_name_pts)
num_tagged = model.get_num_tagged(user)
num_final_tagged = model.get_num_final_tagged(user)
keen.add_event(
'more_tweets', {
"user": user,
'word': word,
'original tweet': tweet,
'num_tagged': num_tagged,
'num_final_tagged': num_final_tagged,
'points': points
})
tweet_list = model.get_another_tweet(word, tweet)
tweets_gotten = request.form.get('tweets_gotten')
if tweets_gotten > 0:
if len(tweet_list) >= tweets_gotten:
new_tweet = tweet_list[-tweets_gotten]
if new_tweet == tweet:
return "There are no more tweets with \"%s\" in them." % word
else:
new_tweet = unicode(new_tweet, 'utf-8', errors='replace')
return render_template('moretweets.html',
tweet=Markup(new_tweet).unescape())
else:
new_tweet = "There are no more tweets with \"%s\" in them." % word
return render_template('moretweets.html', tweet=new_tweet)
else:
new_tweet = "There are no more tweets with \"%s\" in them." % word
return render_template('moretweets.html', tweet=new_tweet)
def get_query(self):
query = super(AlltoezSearchView, self).get_query()
try:
keen.add_event('search', {"query": query}, timezone.now())
except keen.InvalidEnvironmentError:
pass
return query
def handle_results(results, options):
"""
results is a dict that maps from hostname to whether that host had the proc running
"""
found_proc_on_all_hosts = True
missing_hosts = []
for (host, found_proc) in results.iteritems():
if not found_proc:
found_proc_on_all_hosts = False
missing_hosts.append(host)
if not found_proc_on_all_hosts:
# we didn't find the proc, alert
text = "Can't find process {} on the following hosts:\n\n".format(options.process)
missing_hosts = sorted(missing_hosts)
for host in missing_hosts:
text += host + "\n"
emailer.Emailer.send_email(addr_to=options.email, subject="Can't find process {}".format(options.process),
text=text, categories=["processmon"])
keen.add_event("processmon", {
"process": options.process,
"missing_hosts": missing_hosts,
"found_on_all_hosts": found_proc_on_all_hosts
})
def handle_results(results, options):
"""
results is a dict that maps from hostname to whether that host had the proc running
"""
found_proc_on_all_hosts = True
missing_hosts = []
for (host, found_proc) in results.iteritems():
if not found_proc:
found_proc_on_all_hosts = False
missing_hosts.append(host)
if not found_proc_on_all_hosts:
# we didn't find the proc, alert
text = "Can't find process {} on the following hosts:\n\n".format(
options.process)
missing_hosts = sorted(missing_hosts)
for host in missing_hosts:
text += host + "\n"
emailer.Emailer.send_email(addr_to=options.email,
subject="Can't find process {}".format(
options.process),
text=text,
categories=["processmon"])
keen.add_event(
"processmon", {
"process": options.process,
"missing_hosts": missing_hosts,
"found_on_all_hosts": found_proc_on_all_hosts
})
def webhooks():
try:
data = json.loads(request.data)
keen.add_event('gh', data)
return "OK"
except Exception, e:
print e
def search(input, sender=None, postback=False):
if postback:
payload = json.loads(input)
intent = payload['intent']
entities = payload['entities']
else:
if "math" in input:
intent = "math"
entities = input.replace("math", "")
else:
intent, entities = process_query(input)
# TODO: Needs to be refactored out
try:
keen.project_id = os.environ.get('KEEN_PROJECT_ID',
config.KEEN_PROJECT_ID)
keen.write_key = os.environ.get('KEEN_WRITE_KEY',
config.KEEN_WRITE_KEY)
keen.add_event(
'logs', {
'intent': intent,
'entities': entities,
'input': input,
'sender': sender,
'postback': postback
})
except:
pass # Could not stream data for analytics
if intent is not None:
if intent in src.__personalized__ and sender is not None:
r = requests.get('https://graph.facebook.com/v2.6/' + str(sender),
params={
'fields':
'first_name',
'access_token':
os.environ.get('ACCESS_TOKEN',
config.ACCESS_TOKEN)
})
if entities is None:
entities = {}
entities['sender'] = r.json()
data = sys.modules['modules.src.' + intent].process(input, entities)
if data['success']:
return data['output']
else:
if 'error_msg' in data:
return data['error_msg']
else:
return TextTemplate(
'Something didn\'t work as expected! I\'ll report this to my master.'
).get_message()
else:
message = TextTemplate(
'I\'m sorry; I\'m not sure I understand what you\'re trying to say.\nTry typing "help" or "request"'
).get_message()
message = add_quick_reply(message, 'Help',
modules.generate_postback('help'))
message = add_quick_reply(message, 'Request',
modules.generate_postback('request'))
return message
def _transmit_event(self):
# block indefinitely until we get an item (should be 1)
c, e = self._keen_queue.get(True, None)
try:
keen.add_event(c, e)
except ConnectionError:
# we cannot reach the internet, so drop the event
pass
def event(event_name, extra_data_dict={}):
"""
Log an event to the analytics backend
"""
keen_enabled = len(os.environ.get("KEEN_PROJECT_ID", '')) > 0
if keen_enabled:
keen.add_event(event_name, extra_data_dict)
logger.info('%s: %s', event_name, extra_data_dict)
def track(serialized):
try:
payload = serializer.loads(serialized)
event = payload.pop('event', 'footsteps')
keen.add_event(event, payload)
except BadSignature:
abort(404)
return redirect(payload['url'])
def mark_user_views_event(event_id, user_id, ip_address):
if user_id:
view = View()
view.event_id = event_id
view.user_id = user_id
view.save()
ipview, created = ViewIP.objects.get_or_create(event_id=event_id, ip_address=ip_address)
ipview.count = F('count') + 1
ipview.save()
# Send info to keen
staff_status = False
if user_id:
try:
user = get_user_model().objects.get(pk=user_id)
staff_status = user.is_staff
except get_user_model().DoesNotExist:
keen.add_event("Error", {
"msg": "User.DoesNotExist",
"id": user_id
})
event = Event.objects.get(pk=event_id)
keen_events = []
for category in event.category.all():
keen_events.append({
'keen': {
'time_stamp': timezone.now().isoformat(),
'location': {
'coordinates': [float(event.venue.longitude), float(event.venue.latitude)],
}
},
"user": {
"user_id": user_id,
"staff": staff_status,
"ip": ip_address
},
"event": {
"event_id": event_id,
"category": category.name,
"min_age": event.min_age,
"max_age": event.max_age,
"cost": event.cost,
"start_date": event.start_date.isoformat(),
"end_date": event.end_date.isoformat() if event.end_date else None,
"publish_date": event.published_at.isoformat() if event.published_at else None
},
"venue": {
"venue_id": event.venue.id,
"name": event.venue.name,
"city": event.venue.city,
"neighborhood": event.venue.neighborhood,
}})
keen.add_events({"view_single": keen_events})
def setUp(self):
super(QueryTests, self).setUp()
keen._client = None
keen.project_id = "5004ded1163d66114f000000"
api_key = "2e79c6ec1d0145be8891bf668599c79a"
keen.write_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]})
keen.read_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["read"]})
keen.add_event("query test", {"number": 5, "string": "foo"})
keen.add_event("step2", {"number": 5, "string": "foo"})
def get_query(self):
query = super(AlltoezSearchView, self).get_query()
try:
keen.add_event('search', {
"query": query
}, timezone.now())
except keen.InvalidEnvironmentError:
pass
return query
def add_event(*args):
"""Attempt to add an event to keen, print the event otherwise"""
try:
import keen
keen.add_event(*args)
except Exception:
print("Failed to log keen event:")
print(f" {args}")
def ghrequest(
self,
method,
url,
json=None,
*,
override_accept_header=None,
raise_for_status=True,
):
accept = ACCEPT_HEADER
if override_accept_header:
accept = override_accept_header
def prepare():
atk = self.token()
headers = {
"Authorization": "Bearer {}".format(atk),
"Accept": accept,
"Host": "api.github.com",
"User-Agent": "python/requests",
}
req = requests.Request(method, url, headers=headers, json=json)
return req.prepare()
with requests.Session() as s:
response = s.send(prepare())
if response.status_code == 401:
self.regen_token()
response = s.send(prepare())
if raise_for_status:
response.raise_for_status()
rate_limit = response.headers.get("X-RateLimit-Limit", -1)
rate_remaining = response.headers.get("X-RateLimit-Limit", -1)
if rate_limit:
repo_name_list = [
k for k, v in self.idmap.items()
if v == self.installation_id
]
repo_name = "no-repo"
if len(repo_name_list) == 1:
repo_name = repo_name_list[0]
elif len(repo_name_list) == 0:
repo_name = "no-matches"
else:
repo_name = "multiple-matches"
import keen
keen.add_event(
"gh-rate",
{
"limit": int(rate_limit),
"rate_remaining": int(rate_remaining),
"installation": repo_name,
},
)
return response
def _keen_add_event(event_type, data, count):
try:
keen.add_event(event_type, data)
print 'success'
except Exception as e:
print e
if count < settings.KEEN_MAX_RETRIES:
worker_queue.enqueue(_keen_add_event, event_type, data, count + 1)
else:
print 'Keen failed too many times, {}'.format(event_type)
def subscribe():
m = get_mailchimp_api()
lid = '3c734f704d'
if request.method == 'POST' and request.form['EMAIL']:
m.lists.subscribe(lid, {'email': request.form['EMAIL']})
keen.add_event("subscribed", {})
flash("Awesome! You'll receive an email to confirm your subscription.")
else:
flash("Enter your email address to subscribe!")
return redirect(url_for('main.entries'))
def suggest():
form = SuggestForm()
keen.add_event("view", {"page": "suggest"})
if form.validate_on_submit():
suggestion = form.suggestion.data
# add mongodb update stuff here
db.suggestions.insert({"suggestion": suggestion})
flash('Thanks for your suggestion!')
return redirect('/index')
return render_template('suggest.html', form=form)
def index():
choose_method = ["popular", "trending"]
method = random.choice(choose_method)
if method == "popular":
timeframe = "this_1_years"
if method == "trending":
timeframe = "this_7_days"
keen.add_event("view", { "page": method })
videos = keen.count("video_view", timeframe=timeframe, group_by="page", order_by={"property_name": "result", "direction": keen.direction.ASCENDING})
return render_template('home.html', videos=videos, playlist_url=playlist_url)
def popular():
choose_method = ["popular", "trending"]
method = random.choice(choose_method)
if method == "popular":
timeframe = "this_1_years"
if method == "trending":
timeframe = "this_7_days"
keen.add_event("view", { "page": method })
popular_videolist = keen.count("video_view", timeframe=timeframe, group_by="page")
return render_template('popular.html', popular_videolist=popular_videolist)
def setUp(self):
super(QueryTests, self).setUp()
keen._client = None
keen.project_id = "5004ded1163d66114f000000"
api_key = "2e79c6ec1d0145be8891bf668599c79a"
keen.write_key = scoped_keys.encrypt(api_key,
{"allowed_operations": ["write"]})
keen.read_key = scoped_keys.encrypt(api_key,
{"allowed_operations": ["read"]})
keen.add_event("query test", {"number": 5, "string": "foo"})
keen.add_event("step2", {"number": 5, "string": "foo"})
def keen_add_event(event_collection, payload):
'''
Wrapper for keen.add_event(), adds project info
Param event_collection : collection event data is submitted to
Param payload : data that is submitted
'''
# add project info to this event
payload = add_project_info_dict(payload)
# submit list of events to Keen.io
keen.add_event(event_collection, payload)
def __init__(self, commands, config):
keen.add_event("status", {"state": "starting"})
self.commands = commands
self.port = int(os.environ.get('PORT', 5000))
self.application = None
self.config = config
self.auth = Authenticator(self.config.integration_id, self.config.key,
self.config.personnal_account_token,
self.config.personnal_account_name)
self.auth._build_auth_id_mapping()
def video(video):
tags = list_to_string(video)
search_term = tags + " -" + video
videos = search(search_term)
amount_of_related_videos = len(videos)
random_videos_to_get = 8 - amount_of_related_videos
random_videos = db.videos.find().limit(random_videos_to_get)
videos.append(random_videos)
referring_url = request.headers.get("Referer")
keen.add_event("view", {"page": "video"})
keen.add_event("video_view", {"page": video })
return render_template('video.html', video=video, videos=videos, tags=tags)
def send_to_server(self, unused_addr):
keen.add_event(
"vardeDataLog", {
"trappeV": self.trappeV,
"bevaegelse": self.bevaegelse,
"trappeH": self.trappeH,
"sojleV": self.sojleV,
"sojleH": self.sojleH,
"week_day": self.week_day,
"gehl_day": self.gehl_day
})
print("Log seent to Keen.io at: ", time.strftime('%X %x'))
def register():
if request.method == 'POST':
name = request.form.get('name')
pw = request.form.get('pw')
verify_pw = request.form.get('verify_pw')
if len(name) > 0 and len(pw) > 0 and len(verify_pw) > 0:
name_is_alphanum = model.check_alphanum(name)
pw_is_alphanum = model.check_alphanum(pw)
if name_is_alphanum == False:
flash(
'Invalid user name. Alphanumeric characters only (A-Z, a-z, 0-9).'
)
return render_template("register.html")
elif pw_is_alphanum == False:
flash(
'Invalid password. Alphanumeric characters only (A-Z, a-z, 0-9).'
)
return render_template("register.html")
elif 2 > len(name) or 15 < len(name):
flash(
'Invalid user name. User name must be between 2 and 15 characters.'
)
return render_template("register.html")
elif 6 > len(pw) or 15 < len(pw):
flash(
'Invalid password. Password must be between 6 and 15 characters.'
)
return render_template("register.html")
elif pw != verify_pw:
flash('Passwords must match.')
return render_template("register.html")
elif (pw == verify_pw) and name:
if model.check_if_user(name) == True:
flash('You\'re already registered. Please sign in.')
return redirect(url_for('signin'))
else:
model.set_user(name)
model.set_user_pw(name, pw)
keen.add_event('register', {'username': name})
flash('Thanks for registering! You\'re now signed in.')
session['user'] = name
return redirect(url_for('index'))
else:
flash('All fields are required.')
return render_template("register.html")
elif not session:
return render_template("register.html")
else:
# if there's a session
flash('You\'re already signed in.')
return redirect(url_for('index'))
def add_event(event_collection, payload):
"""
Wrapper for keen.add_event(), adds project info.
Param event_collection : collection event data is submitted to
Param payload : data that is submitted
"""
# add project info to this event
payload = add_project_info_dict(payload)
# submit list of events to Keen.io
keen.add_event(event_collection, payload)
logger.info(
"Sent single event to '%s' collection (Keen.io)",
event_collection
)
def test_malformed_json_response(self, post):
post.return_value = MockedMalformedJsonResponse(
status_code=401,
json_response=" ",
text="test error text"
)
exception = None
try:
keen.add_event("python_test", {"hello": "goodbye"})
except exceptions.KeenApiError as e:
exception = e
self.assertTrue(post.return_value.text in str(exception))
self.assertTrue(str(post.return_value.status_code) in str(exception))
def keen_hit(type, resource, request):
if not settings.KEEN_DEBUG:
ip = request.META.get('REMOTE_ADDR')
user_agent = request.META.get('HTTP_USER_AGENT')
try:
keen.add_event(
"api_hit",
{
"url": request.path,
"type": type,
"resource": resource,
"ip_address": ip,
"user_agent": user_agent
}
)
except:
logging.warning("Couldn't send event to keen")
def register():
if request.method == 'POST':
name = request.form.get('name')
pw = request.form.get('pw')
verify_pw = request.form.get('verify_pw')
if len(name) > 0 and len(pw) > 0 and len(verify_pw) > 0:
name_is_alphanum = model.check_alphanum(name)
pw_is_alphanum = model.check_alphanum(pw)
if name_is_alphanum == False:
flash('Invalid user name. Alphanumeric characters only (A-Z, a-z, 0-9).')
return render_template("register.html")
elif pw_is_alphanum == False:
flash('Invalid password. Alphanumeric characters only (A-Z, a-z, 0-9).')
return render_template("register.html")
elif 2 > len(name) or 15 < len(name):
flash('Invalid user name. User name must be between 2 and 15 characters.')
return render_template("register.html")
elif 6 > len(pw) or 15 < len(pw):
flash('Invalid password. Password must be between 6 and 15 characters.')
return render_template("register.html")
elif pw != verify_pw:
flash('Passwords must match.')
return render_template("register.html")
elif (pw == verify_pw) and name:
if model.check_if_user(name) == True:
flash('You\'re already registered. Please sign in.')
return redirect(url_for('signin'))
else:
model.set_user(name)
model.set_user_pw(name, pw)
keen.add_event('register', {
'username':name
})
flash('Thanks for registering! You\'re now signed in.')
session['user'] = name
return redirect(url_for('index'))
else:
flash('All fields are required.')
return render_template("register.html")
elif not session:
return render_template("register.html")
else:
# if there's a session
flash('You\'re already signed in.')
return redirect(url_for('index'))
def home():
# seminars = retrieveSeminars()
# pickle.dump(seminars, open("seminars.pickle", "wb"))
seminars = pickle.load(open("seminars.pickle", "rb"))
form = request.form.copy()
if request.method == 'POST':
alert = ""
searchKeywords = str(form['searchquery'])
fallTerm = True if form.get('fallterm') else False
springTerm = True if form.get('springterm') else False
allConflictValues = {k: v for k, v in form.iteritems()
if k.startswith("conflict")}
conflicts = []
numNextConflict = 1
moreConflicts = True
while moreConflicts:
if allConflictValues.get("conflict" +
str(numNextConflict) + "-day"):
conflicts.append(
{"days": form.getlist(
"conflict" + str(numNextConflict) + "-day"),
"starttime": allConflictValues.get(
"conflict" + str(numNextConflict) + "-starttime"),
"endtime": allConflictValues.get(
"conflict" + str(numNextConflict) + "-endtime")})
numNextConflict += 1
else:
moreConflicts = False
keen.add_event("seminar_loads",
{"ip" : request.remote_addr,
"fallterm" : str(fallTerm),
"springterm" : str(springTerm),
"searches": str(searchKeywords),
"conflicts": str(conflicts) })
seminarsToDisplay = filterSeminars(
seminars, fallTerm, springTerm, conflicts, searchKeywords)
return render_template(
'index.html', seminars=seminarsToDisplay, alert=alert)
keen.add_event("homepage_loads", {"ip":request.remote_addr})
return render_template('index.html')
def search(input, sender=None, postback=False):
if postback:
payload = json.loads(input)
intent = payload['intent']
entities = payload['entities']
else:
intent, entities = process_query(input)
# TODO: Needs to be refactored out
try:
keen.project_id = os.environ.get('KEEN_PROJECT_ID', config.KEEN_PROJECT_ID)
keen.write_key = os.environ.get('KEEN_WRITE_KEY', config.KEEN_WRITE_KEY)
keen.add_event('logs', {
'intent': intent,
'entities': entities,
'input': input,
'sender': sender,
'postback': postback
})
except:
pass # Could not stream data for analytics
if intent is not None:
if intent in src.__personalized__ and sender is not None:
r = requests.get('https://graph.facebook.com/v2.6/' + str(sender), params={
'fields': 'first_name',
'access_token': os.environ.get('ACCESS_TOKEN', config.ACCESS_TOKEN)
})
if entities is None:
entities = {}
entities['sender'] = r.json()
data = sys.modules['modules.src.' + intent].process(input, entities)
if data['success']:
return data['output']
else:
if 'error_msg' in data:
return data['error_msg']
else:
return TextTemplate('Something didn\'t work as expected! I\'ll report this to my master.').get_message()
else:
message = TextTemplate(
'I\'m sorry; I\'m not sure I understand what you\'re trying to say.\nTry typing "help" or "request"').get_message()
message = add_quick_reply(message, 'Help', modules.generate_postback('help'))
message = add_quick_reply(message, 'Request', modules.generate_postback('request'))
return message
def test_direct_persistence_strategy(self, post):
post.return_value = self.SINGLE_ADD_RESPONSE
keen.add_event("python_test", {"hello": "goodbye"})
keen.add_event("python_test", {"hello": "goodbye"})
post.return_value = self.MULTI_ADD_RESPONSE
keen.add_events(
{
"sign_ups": [{
"username": "******",
"referred_by": "steve",
"son_of": "my_mom"
}],
"purchases": [
{"price": 5},
{"price": 6},
{"price": 7}
]}
)
def post(self):
if not self.is_taskqueue_request():
logging.error('Request outside of task queue.')
return
visit_key = self.request.POST.get('visit_key', '')
visit = ndb.Key(urlsafe=visit_key).get()
if not visit:
logging.error('Invalid visit key passed: {visit_key}'
.format(visit_key=visit_key))
return
# Shoot the event off to keen.
logging.info('Successfully sent {visit_key} to keen.io'
.format(visit_key=visit_key))
# Don't send data from development app server.
if not DEBUG:
keen.add_event('visits', serialize_ndb_model(visit))
def main():
global DEBUG
args = docopt(__doc__)
if args['--debug']:
DEBUG = True
poloniex = Poloniex()
max_demand = poloniex.get_max_demand_rate()
min_offer = poloniex.get_min_offer_rate()
min_big_offer = poloniex.get_min_offer_rate(BTC_PER_BIG_OFFER)
print "max_demand:", max_demand,
print "min_offer:", min_offer,
print "min_big_offer:", min_big_offer
if not DEBUG:
keen.add_event("lending-rates", {
"max-demand": max_demand,
"min-offer": min_offer,
"min-big-offer": min_big_offer
})
def upload():
uploaded = request.files['file']
if not uploaded:
return redirect('/')
file_info = {'filename': uploaded.filename, 'mimetype': uploaded.mimetype}
try:
image = Image.open(uploaded)
except IOError:
app.logger.info('Bad Upload - {}'.format(file_info))
if BRICKY_ENV == LIVE:
keen.add_event('bad_upload', file_info)
return redirect('/')
new_size = legofy.get_new_size(image, BRICK_IMAGE)
image.thumbnail(new_size, Image.ANTIALIAS)
lego_image = legofy.make_lego_image(image, BRICK_IMAGE)
new_image = io.BytesIO()
lego_image.save(new_image, format='PNG')
new_image.seek(0)
browser_info = {'user_agent': request.headers.get('User-Agent', 'No Agent'),
'X-Request-ID': request.headers.get('X-Request-ID', 'Missing X-Request-ID')}
app.logger.info('Headers - {}'.format(browser_info))
app.logger.info('Upload - {}'.format(file_info))
if BRICKY_ENV == LIVE:
keen.add_event('browser', browser_info)
keen.add_event('upload', file_info)
response = send_file(new_image, mimetype='image/png')
response.headers['Last-Modified'] = datetime.now()
response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0'
response.headers['Pragma'] = 'no-cache'
response.headers['Expires'] = '-1'
return response
def keen_log(bot, message):
"Log every message in a channel to keen"
# setup keen keys
keen.project_id = apikey.keen_project_id
keen.write_key = apikey.keen_write_key
keen.read_key = apikey.keen_read_key
# if this is a private message and we're not logging those, return early
if message.sender.is_nick() and not bot.config.chanlogs.privmsg:
return
channel = bot.origin.sender.lstrip("#")
nick = str(bot.origin.nick)
# determine which message type
if message.startswith("\001ACTION ") and message.endswith("\001"):
message_type = "ACTION"
message = message[8:-1]
else:
message_type = "MESSAGE"
message_dict = {'type': message_type, 'channel': channel, 'nick': nick, 'text': message}
keen.add_event('message', {'type': message_type, 'channel': channel, 'nick': nick, 'text': message})
def play_game():
tag = request.form.get('tag')
word = request.form.get('word')
tweet = request.form.get('tweet')
user = session['user']
num_tagged = model.get_num_tagged(user)
num_final_tagged = model.get_num_final_tagged(user)
if tag and word:
# set the tag for the user and the tweet
model.tag_word_game(word, tag, user, tweet)
# add points and set final tag if needed
model.add_pts_game(word, tag, user)
# retrieve how many points user has
user_name_pts = "user_%s_pts"%user
num_points = model.get_string_num(user_name_pts)
keen.add_event("button_press", {
"tag":tag,
"word":word,
"user":user,
"num_tagged":num_tagged,
"num_final_tagged":num_final_tagged,
"points":num_points
})
return str(num_points)
def new_action(event_type, user_id, event_id, session_id=None):
"""
Create a new event on pio server
:param event_type:
:param user_id:
:param event_id:
:param session_id:
:return:
"""
staff_status = False
if user_id:
try:
user = get_user_model().objects.get(pk=user_id)
staff_status = user.is_staff
except get_user_model().DoesNotExist:
keen.add_event("Error", {
"msg": "User.DoesNotExist",
"id": user_id
})
try:
event = Event.objects.get(pk=event_id)
keen.add_event(event_type, {
"user": {
"user_id": user_id,
"staff": staff_status,
"session_id": session_id
},
"event": {
"event_id": event_id,
"categories": list(event.category.all().values_list('name', flat=True)),
"min_age": event.min_age,
"max_age": event.max_age,
"cost": event.cost,
"start_date": event.start_date.isoformat(),
"end_date": event.end_date.isoformat() if event.end_date else None,
"publish_date": event.published_at.isoformat() if event.published_at else None
},
"venue": {
"venue_id": event.venue.id,
"name": event.venue.name,
"city": event.venue.city,
"neighborhood": event.venue.neighborhood,
}
}, timezone.now())
except Event.DoesNotExist:
keen.add_event("Error", {
"msg": "Event.DoesNotExist",
"id": event_id
})
import keen
import pandas as pd
import json
keen.project_id = "[xxxxx]"
keen.write_key = "[xxxxx]"
keen.read_key = "[xxxxx]"
df = pd.read_csv('filename.csv', low_memory=False)
collname = 'filename'
recs = len(df)
cols = df.columns
i = 0
recs = len(df)
while i < recs:
y = {}
j = 0
while j < len(cols):
# need to put stuff in the appropriate double quotes where required....
y[cols[j]] = df[cols[j]][i]
j += 1
# yz = json.dumps(y)
keen.add_event(collname, y)
i += 1
x = keen.count(collname)
print x
def test_module_level_add_event(self):
keen.project_id = "5004ded1163d66114f000000"
api_key = "2e79c6ec1d0145be8891bf668599c79a"
keen.write_key = scoped_keys.encrypt(api_key, {"allowed_operations": ["write"]})
# client = KeenClient(project_id, write_key=write_key, read_key=read_key)
keen.add_event("python_test", {"hello": "goodbye"})
