def next(self, readonly=True, search='NEW'):
for folder in self.folders:
self.con.select(folder, readonly=readonly)
for (uid, msg, flags) in get_messages(self.con, folder,
"UNSEEN %s" % search):
self.con.store(uid, "-FLAGS", '\Seen')
log.info('%s %s %s', folder, uid, msg['Subject'])
yield uid, flags, process_message(msg, self.porter, None)
for (uid, msg, flags) in get_messages(self.con, folder,
"SEEN %s" % search):
log.info('%s %s %s', folder, uid, msg['Subject'])
yield uid, flags, process_message(msg, self.porter, None)
def index():
headers = {'Content-Type': 'text/html'}
messages = get_messages()
return make_response(
render_template('index.html',
title="Welcome to the Palindrome Checker",
messages=messages), 200, headers)
async def mood_chat_bot_handler(event):
_mood = mood()
if event.is_private or event.is_group and config["!DEFAULT!"][
"bot_name"] in event.raw_text.lower():
available_keys = ({
**get_messages("normal", "mood_chat_bot"),
**get_messages("groups_auto", "mood_chat_bot")
} if event.mentioned is False else {
**get_messages("normal", "mood_chat_bot"),
**get_messages("reply"),
**get_messages("groups_auto", "mood_chat_bot")
})
time_key = get_messages("exceptions",
"mood_chat_bot")["time"][mood_to_words(_mood)]
for word in time_key:
if word in event.raw_text.lower():
await event.reply(time_key[word][randrange(
0, len(time_key[word]))])
return
for word in available_keys:
if word in event.raw_text.lower():
if len(available_keys[word]) != 3:
_mood = 0
(await (event.reply(available_keys[word][_mood]))
if available_keys[word][_mood] != "" else None)
return
if config["!DEFAULT!"]["bot_name"] in event.raw_text.lower().replace(
" ", "") or event.is_private:
await event.reply(time_key["other"][randrange(
0, len(time_key["other"]))])
return
if event.is_group:
available_keys = (get_messages("groups_auto", "mood_chat_bot")
if event.mentioned is False else {
**get_messages("normal", "mood_chat_bot"),
**get_messages("reply", "mood_chat_bot"),
**get_messages("groups_auto", "mood_chat_bot")
})
for word in available_keys:
if word in event.raw_text.lower():
if len(available_keys[word]) != 3:
_mood = 0
await event.reply(available_keys[word][_mood])
def get(self):
context = {
'urls': models.Url.all(),
'dashboards': models.Dashboard.all(),
'error': self.request.get('e'),
'messages': get_messages()
}
self.response.out.write(template.render('templates/admin/urls.html', context))
def post(self):
if self.request.get('method') == 'delete':
self.delete()
else:
context = {
'urls': models.Url.all(),
'dashboards': models.Dashboard.all(),
'adding': self.request.get('model'),
'fields': {
'name': self.request.get('name'),
'url': self.request.get('url'),
'dashboard': self.request.get('dashboard'),
'dashboardname': self.request.get('dashboard-name'),
'dashboardid': self.request.get('dashboard-id')
}
}
if context['adding'] == 'url':
link = 'http://' + self.request.get('url').replace('http://', '')
if check_http_200(link):
try:
url = models.Url(
name=self.request.get('name'),
url=link,
dashboard=self.request.get('dashboard'))
url.put()
add_message('URL added successfully.')
return self.redirect('/admin/urls')
except BadValueError:
context['error'] = "BadValueError"
else:
context['error'] = '200'
elif context['adding'] == 'dashboard':
try:
dashboard = models.Dashboard(
name=self.request.get('dashboard-name'),
id=self.request.get('dashboard-id'))
dashboard.put()
add_message('Dashboard added successfully. Now add some test URLs.')
return self.redirect('/admin/urls')
except BadValueError:
context['error'] = "BadValueError"
context['messages'] = get_messages()
logging.debug(context['messages'])
self.response.out.write(template.render('templates/admin/urls.html', context))
def time_range_analysis(data, start, end):
num_messages = {}
for user in get_participants(data):
num_messages[user] = 0
for message in get_messages(data, user):
hour = datetime.datetime.fromtimestamp(
message["timestamp_ms"] / 1000.0).strftime(
'%Y-%m-%d %H:%M:%S.%f').split()[1].split(":")[0]
if int(hour) >= start and int(hour) <= (end - 1):
num_messages[user] += 1
return num_messages
def main(pulse_opts):
global pulse_cfg
pulse_cfg.update(pulse_opts)
publisher = BugzillaPublisher(**pulse_cfg)
count = 0
for msg in get_messages():
bug_data = extract_bug_info(msg)
publish_message(publisher, bug_data, "org.mozilla.bugzilla.exchange")
count += 1
print "Synced %d bug(s) from email" % count
def clean(con):
folders = [
'INBOX/train/important',
'INBOX/test/important',
'INBOX/train/not-important',
'INBOX/test/not-important',
]
for folder in folders:
con.select(folder)
for (uid, msg, flags) in get_messages(con, folder, 'ALL'):
result = con.store(uid, "+FLAGS", '\\Deleted')
log.info('{} {}'.format(uid, result))
con.expunge()
def get(self, username):
self.api_calls = []
context = self.get_from_api('/users/%s' % username)
data = self.get_from_api('/users/%s/questions' % username)
logging.debug(data)
context['answered_questions'] = data['answered_questions']
context['unanswered_questions'] = data['unanswered_questions']
context['api_calls'] = self.api_calls
context['messages'] = utils.get_messages()
context['remaining'] = 100 - context['comparisons']['mp']['politmus_score']
t = template.render('templates/users_user.html', context)
self.response.out.write(t)
def write_all_messages(data, user):
f = open("./../text/%s_words.txt" % user, "w+", encoding="utf-8")
for message in get_messages(data, user):
if "content" in message.keys() and "joined the" not in message[
'content'] and " sent a live location" not in message[
'content'] and "set the emoji to" not in message[
'content'] and "changed the" not in message[
'content'] and "voted for" not in message[
'content'] and "set your nickname" not in message[
'content'] and "set the nickname" not in message[
'content'] and "created a poll" not in message[
'content']:
f.write(message["content"])
f.close()
def get(self, username):
self.api_calls = []
context = self.get_from_api('/users/%s' % username)
data = self.get_from_api('/users/%s/questions' % username)
logging.debug(data)
context['answered_questions'] = data['answered_questions']
context['unanswered_questions'] = data['unanswered_questions']
context['api_calls'] = self.api_calls
context['messages'] = utils.get_messages()
context[
'remaining'] = 100 - context['comparisons']['mp']['politmus_score']
t = template.render('templates/users_user.html', context)
self.response.out.write(t)
def messages_script():
chat_id = 100
nmessages = 3000
messages = utils.get_messages(api, chat_id=chat_id, nmessages=nmessages)
msg_stats, = utils.data_to_dict(
handler_list=[handlers.user_messages_count], data=messages)
users = utils.get_chat_users(api, chat_id)
utils.get_users(api, user_ids=msg_stats, user_dict=users)
names = utils.get_full_names(users)
views.dict_view(view_method=views.plotly_hist,
keys=sorted(list(msg_stats.keys()),
key=lambda item: msg_stats[item]),
label_dict=names,
data_dict=msg_stats,
rate=False)
def _get(self, *args, **kwargs):
if not self.request.user.is_authenticated():
return [], False
return (map(lambda m: m.as_message(), get_messages(self.request.user)),
True)
def get_queryset(self):
return get_messages(self.request.user)
# -*- coding: utf-8 -*-
import manage
from kyuuyaku.models import *
from utils import get_messages
Message.objects.all().delete()
for pointer, message in sorted(get_messages().items()):
Message(pointer=pointer, data=message).save()
'INBOX/test/not-important',
]
for folder in folders:
con.select(folder)
for (uid, msg, flags) in get_messages(con, folder, 'ALL'):
result = con.store(uid, "+FLAGS", '\\Deleted')
log.info('{} {}'.format(uid, result))
con.expunge()
if __name__ == "__main__":
folders = ['INBOX']
unknown_words = []
con = get_connection()
clean(con)
for folder in folders:
log.info(folder)
con.select(folder, readonly=True)
for (uid, msg, flags) in get_messages(con, folder, 'ALL'):
log.info("%s %s", uid, flags)
label = get_label(flags)
if label is None:
continue
mode = 'test' if (int(uid) % 10) >= 8 else 'train'
result = con.copy(
uid, 'INBOX/{0}/{1}'.format(
mode, 'important' if label else 'not-important'))
def list_messages(version):
if version.lower() == 'v1':
if len(request.args.to_dict()) > 0:
abort(400, 'This version does not accept additional parameters')
return utils.get_messages(version, request.args.get('format', 'JSON'))
# -*- coding: utf-8 -*-
from utils import get_messages, gen_formatted
from collections import defaultdict
kanji = set([])
unknown = defaultdict(int)
f = open("output.txt", "w")
for address, message in sorted(get_messages().items()):
if len(message) < 3:
continue
message = [int(m, 16) for m in message.split()]
formatted, unk = gen_formatted(message)
if len(formatted) < 2:
continue
f.write("0x%x\n--------\n" % address)
for key, value in unk.items():
if value:
unknown[key] += value
f.write(formatted.encode('utf-8'))
f.write("\n\n--------\n")
for char, count in sorted(unknown.items(), key=lambda (x,y): y, reverse=True):
f.write(("%x" % char).zfill(4) + " %d\n" % count)
f.write('\n')
for char, count in sorted(sorted(unknown.items(), key=lambda (x,y): y, reverse=True)[:10]):
f.write(("%x" % char).zfill(4) + " %d\n" % count)
PLAYER = None
else:
UNI.create_player(PLAYER)
players = UNI.players.keys()
current_player = UNI.players[PLAYER]
p.subscribe('GAMEWORLD')
r.publish('GAMEWORLD', '{} joins the game... {}'.format(current_player.name,
uuid.uuid4()))
command = None
while command != 'Q':
neighbors = UNI.graph.neighbors(current_player.current_node)
print("".join(utils.get_messages(current_player.current_node,
current_player,
neighbors,
UNI)))
clock = datetime.now().strftime('%H:%M:%S')
command = input("Command [TL={}]:[{}] (?=Help) : ".format(clock,
current_player.current_node)
)
command = command.upper()
if command not in ['Q', 'V', 'P', '?'] and (command.isnumeric() or utils.is_float(command)):
try:
target_node = int(command)
except ValueError:
target_node = float(command)
if target_node in neighbors:
current_player.current_node = target_node
current_player.sectors_visited.update({current_player.current_node: 1})
import email
import datetime
from email.parser import Parser
from utils import get_messages, extract_bug_info
from mongotools import MongoConnection
from tools import classify_volunteer
with MongoConnection() as conn:
count = 0
for msg in get_messages():
try:
all_data = extract_bug_info(msg)
except:
continue
who = all_data['changed_by']
all_data.pop('changed_by')
author_info = who
if 'author_name' in all_data:
author_info += " " + all_data['author_name']
all_data.pop('author_name')
volunteer = classify_volunteer(author_info)
all_data['volunteer_assignee'] = classify_volunteer(all_data['assignee'])
when_str = all_data['changed_at']
when_tuple = email.utils.parsedate_tz(when_str)
when = datetime.datetime.fromtimestamp(email.utils.mktime_tz(when_tuple))
all_data.pop('changed_at')
source = 'bugzilla'
