def create_task():
if (len(request.form) == 0):
abort(400)
url = request.form.get('url')
if (url == None or len(url) >= 256):
abort(400)
email = request.form.get('email')
token = queue.enqueue(run_task, url, email)
return jsonify({"id": token.id})
def add_task():
url = ''
jobs = ''
message = None
q_len = len(queue)
f_len = len(queue.finished_job_registry)
if request.method == 'POST':
url = request.form.get('url')
if url.startswith('http://') or url.startswith('https://'):
queue.enqueue(count_words, url, result_ttl=600, ttl=40)
jobs = queue.jobs
else:
message = "Url must be start with https:// or http://"
return render_template(
"tasks/index.html",
jobs=jobs,
url=url,
q_len=q_len,
f_len=f_len,
message=message,
)
def get_counts():
data = json.loads(request.data.decode())
print(34343434, data)
text = data["text"]
print(32323232, type(text))
print(32323232, text)
# flash('Your text is being processed - {}'.format(text))
list_sentences = handle_form_text(text)
print(1, list_sentences)
job = queue.enqueue(google_app.yandex, list_sentences)
# session['key'] = job.id
# print(11111111111, session['key'])
return job.get_id()
def task(task_id):
if not check_access():
return go_away()
current_task = Task.query.filter_by(id=task_id).first()
current_user = get_current_user()
if current_task is None:
return raise_error('Задание с id {} не существует'.format(task_id))
if request.method == 'POST':
file = request.files['solution']
language = int(request.form['language'])
code = file.read()
attempt = Attempt(task=current_task,
language=language,
sender=current_user,
code=code)
update(attempt)
job = queue.enqueue('checker.check_attempt', attempt)
attempt.queue_id = job.get_id()
update(attempt)
with open('solutions/{}.code'.format(attempt.id),
mode='w+',
encoding='utf8') as f:
f.write(('#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n'
if language == 1 else '') + code.decode('utf8'))
file.close()
examples_of_tests = []
for i in range(1, current_task.examples_of_tests + 1):
if not os.path.exists('tests/{}/{}.in'.format(current_task.id, i)):
break
with open('tests/{}/{}.in'.format(current_task.id, i)) as f:
examples_of_tests.append([f.read()])
with open('tests/{}/{}.out'.format(current_task.id, i)) as f:
examples_of_tests[i - 1].append(f.read())
if request.args.get('all') is None or check_access(1, higher=False):
return render('task.html',
task=current_task,
attempts=Attempt.query.filter_by(
sender=current_user, task=current_task).order_by(
Attempt.time_created.desc()).all(),
examples_of_tests=examples_of_tests)
return render('task.html',
task=current_task,
attempts=Attempt.query.filter_by(task=current_task).order_by(
Attempt.time_created.desc()).all(),
all=True,
examples_of_tests=examples_of_tests)
def viewRecentBills():
global utility_referral
global queue
global job_id
utility_referral = request.args.get('referral')
print(utility_referral)
job = queue.enqueue('app.tasks.getUtilityBillv2',
args=(utility_referral, ))
job.refresh()
job_id = str(job.get_id())
loading = """
<div class="d-flex justify-content-center">
<div class="spinner-border" role="status">
<span class="sr-only">Loading...</span>
</div>
</div>
"""
return render_template('viewRecentBills.html',
title='Due Bill',
loading=loading)
def init(height, width, n_threads):
height = int(height)
width = int(width)
n_threads = int(n_threads)
clear_all()
h_classes = []
t_start = time.time()
for h in range(1, height + 1):
for w in range(1, width + 1):
matrices = []
print(f'Initialization {1 << w * h} {w}x{h} matrices...')
for b in range(0, 1 << w * h):
matrix = get_matrix(h, w, b)
matrices.append(matrix)
alchemy_matrix = Matrix(width=w, height=h, body=b)
db.session.add(alchemy_matrix)
print(f'Computing H-classes for {w}x{h} matrices...')
if n_threads < 1 << w * h and n_threads > 1:
n_matrices = 1 << w * h
s_batch = int(n_matrices / n_threads)
jobs = []
for idx in range(n_threads):
matrix_from = s_batch * idx
matrix_to = min((idx + 1) * s_batch, n_matrices)
jobs.append(
queue.enqueue(partial_h_class,
matrices[matrix_from:matrix_to]))
while any([job.result is None for job in jobs]):
continue
size_h_classes = []
for job in jobs:
size_h_classes.append(job.result)
while len(size_h_classes) > 1:
jobs = []
for idx in range(0, len(size_h_classes), 2):
jobs.append(
queue.enqueue(reduce_h_classes,
size_h_classes[idx],
size_h_classes[idx + 1]))
while any([job.result is None for job in jobs]):
continue
reduced_h_classes = []
for job in jobs:
reduced_h_classes.append(job.result)
size_h_classes = reduced_h_classes
size_h_classes = size_h_classes[0]
else:
size_h_classes = partial_h_class(matrices)
h_classes.extend(size_h_classes)
print('Computing L-classes...')
l_classes = []
for h_class in h_classes:
matrix = h_class[0]
for l_class in l_classes:
class_matrix = l_class[0]
if l_equivalent(matrix, class_matrix):
l_class.extend(h_class)
break
else:
l_class = []
l_class.extend(h_class)
l_classes.append(l_class)
print('Computing R-classes...')
r_classes = []
for h_class in h_classes:
matrix = h_class[0]
for r_class in r_classes:
class_matrix = r_class[0]
if r_equivalent(matrix, class_matrix):
r_class.extend(h_class)
break
else:
r_class = []
r_class.extend(h_class)
r_classes.append(r_class)
print('Computing D-classes...')
d_classes = []
for l_class in l_classes:
matrix = l_class[0]
for d_class in d_classes:
class_matrix = d_class[0]
r_class = next(
filter(lambda r_class: class_matrix in r_class, r_classes))
if as_set(l_class) & as_set(r_class):
d_class.extend(l_class)
break
else:
d_class = []
d_class.extend(l_class)
d_classes.append(d_class)
print('Storing H-classes in database...')
for h_class in h_classes:
cls = H_class()
for matrix in h_class:
mtx = find_alchemy_matrix(matrix)
mtx.h_class = cls
print('Storing L-classes in database...')
for l_class in l_classes:
cls = L_class()
for matrix in l_class:
mtx = find_alchemy_matrix(matrix)
mtx.l_class = cls
print('Storing R-classes in database...')
for r_class in r_classes:
cls = R_class()
for matrix in r_class:
mtx = find_alchemy_matrix(matrix)
mtx.r_class = cls
print('Storing D-classes in database...')
for d_class in d_classes:
cls = D_class()
for matrix in d_class:
mtx = find_alchemy_matrix(matrix)
mtx.d_class = cls
db.session.commit()
t_end = time.time()
print(f'Estimated time: {t_end - t_start} s.')
def newTask(taskType):
if taskType == "task1":
return render_template("task1.html")
elif taskType == "task2":
form = Task2Form()
elif taskType == "task3":
form = Task3Form()
elif taskType == "task4":
form = Task4Form()
elif taskType == "task5":
form = Task5Form()
elif taskType == "task6":
form = Task6Form()
if form.validate_on_submit():
if taskType == "task4":
f = form.infile.data
filename = secure_filename(f.filename)
content_type, _ = guess_type(filename)
f_id = fs.put(f, filename=filename, content_type=content_type)
task = {
"input_file": f_id,
"created_at": datetime.datetime.utcnow(),
"task_type": taskType,
"state": "IDLE",
"etc": {
'alpha': form.alpha.data,
'beta': form.beta.data,
'zoom': form.zoom.data
}
}
taskId = db.tasks.insert_one(task).inserted_id
print("INFO: QUEUED TASK " + str(taskId))
rq_task = queue.enqueue('app.tasks.' + taskType, taskId)
task["redis_task"] = rq_task
elif taskType == "task6":
f = form.infile.data
filename = secure_filename(f.filename)
content_type, _ = guess_type(filename)
f_id = fs.put(f, filename=filename, content_type=content_type)
task = {
"input_file": f_id,
"created_at": datetime.datetime.utcnow(),
"task_type": taskType,
"state": "IDLE",
}
taskId = db.tasks.insert_one(task).inserted_id
print("INFO: QUEUED TASK " + str(taskId))
rq_task = queue.enqueue('app.tasks.' + taskType, taskId)
task["redis_task"] = rq_task
elif taskType == "task5":
f = form.infile.data
filename = secure_filename(f.filename)
content_type, _ = guess_type(filename)
f_id = fs.put(f, filename=filename, content_type=content_type)
task = {
"input_file": f_id,
"created_at": datetime.datetime.utcnow(),
"task_type": taskType,
"state": "IDLE",
"etc": {
'isField': form.isField.data
}
}
taskId = db.tasks.insert_one(task).inserted_id
print("INFO: QUEUED TASK " + str(taskId))
rq_task = queue.enqueue('app.tasks.' + taskType, taskId)
task["redis_task"] = rq_task
elif taskType == "task2":
f = form.infile.data
filename = secure_filename(f.filename)
content_type, _ = guess_type(filename)
f_id = fs.put(f, filename=filename, content_type=content_type)
task = {
"input_file": f_id,
"created_at": datetime.datetime.utcnow(),
"task_type": taskType,
"state": "IDLE",
}
taskId = db.tasks.insert_one(task).inserted_id
print("INFO: QUEUED TASK " + str(taskId))
rq_task = queue.enqueue('app.tasks.' + taskType, taskId)
task["redis_task"] = rq_task
elif taskType == "task3":
f = form.infile.data
filename = secure_filename(f.filename)
content_type, _ = guess_type(filename)
f_id = fs.put(f, filename=filename, content_type=content_type)
task = {
"input_file": f_id,
"created_at": datetime.datetime.utcnow(),
"task_type": taskType,
"state": "IDLE",
"etc": {
'alpha': form.alpha.data,
'beta': form.beta.data,
'zoom': form.zoom.data
}
}
taskId = db.tasks.insert_one(task).inserted_id
print("INFO: QUEUED TASK " + str(taskId))
rq_task = queue.enqueue('app.tasks.' + taskType, taskId)
task["redis_task"] = rq_task
return redirect('/viewDetails/' + str(taskId))
return render_template("newTask.html",
title=taskType,
taskType=taskType,
form=form)