def start_train(project_id):
if not current_user.is_authenticated:
print('not logged in')
return redirect(url_for('login'))
content = None
data = None
data = Project.from_user(current_user.user_id)
project_specific_data = []
html = None
titles = None
if Project.check_auth(current_user.user_id, int(project_id)):
project_specific_data = Project.get_one(current_user.user_id,
int(project_id))
if project_specific_data[0]['model_available']:
return jsonify(result='trained')
q.enqueue(DLModel.train_model,
project_specific_data[0]['dataset'][0]['name'],
int(project_id), app.config['UPLOAD_FOLDER'])
Database.update_one(collection='projects',
query=[{
'project_id': int(project_id)
}, {
"$set": {
"in_training": True
}
}])
return jsonify(result='done')
else:
return jsonify(result='error')
def mutate(self, info, **kwargs):
with session_scope() as db_session:
username = kwargs.get("username")
email = kwargs.get("email")
password = kwargs.get("password")
validation.validate_registration(username, email, password)
try:
if current_user.is_authenticated:
raise GraphQLError(_("You are already logged in."))
user = ModelUserAccount(
username=username,
email=email,
password=ModelUserAccount.generate_hash(password),
locale=str(get_locale()),
)
token = encode_token(user.email, verify_email_salt)
verify_url = generate_url("verify_email.verify_email", token)
template = template_env.get_template("verify_email.html")
content = template.render(display_name=username,
verify_url=verify_url)
db_session.add(user)
db_session.flush()
q.enqueue(send_email, user.email,
_("Verify your DofusLab account"), content)
login_user(user)
save_custom_sets(db_session)
except Exception as e:
raise GraphQLError(_("An error occurred while registering."))
return RegisterUser(user=user, ok=True)
def upload_image():
message = None
if request.method == "POST":
image = request.files["image"]
image_dir_name = secrets.token_hex(16)
os.mkdir(os.path.join(upload_directory, image_dir_name))
image.save(
os.path.join(upload_directory, image_dir_name, image.filename))
image_dir = os.path.join(upload_directory, image_dir_name)
print(image.filename)
print(image_dir)
q.enqueue(create_image_set, image_dir, image.filename)
flash("Image uploaded and sent for resizing", "success")
message = f"/image/{image_dir_name}/{image.filename.split('.')[0]}"
return render_template("upload_image.html", message=message)
def send_notification(order, template, method):
""" Send notification by specified method
:order: the order which the notification is related to
:template: the template to use
:method: send notification by which method
"""
user = order.user
order_info = dict(order_id=order.id, order_timestamp=order.timestamp,
order_description=order.description, username=user.nickname)
if method == SEND_METHOD_EMAIL:
subject = template.email_subject.format(**order_info)
body = template.email.format(**order_info)
send_job = q.enqueue(send_email, user.email, subject, body)
elif method == SEND_METHOD_SMS:
send_job = q.enqueue(send_sms,
user.mobile, template.sms.format(**order_info))
elif method == SEND_METHOD_APP:
send_job = q.enqueue(send_app_push,
user, template.app.format(**order_info))
# log after sending job done.
q.enqueue_call(add_log, args=(order, template, method),
depends_on=send_job)
def start_train(project_id):
"""
STRICT API To allow ADMIN user to force sart training for the Deep Leanring Model
Allows an ADMIN user to start traning the user Deep LEarning model
customer's activities. \n\n
API/URL must be accessed with GET request and supply project_id the URL\n
method: GET\n
Args:
project_id (str): ID of the poject/Customer need to be sent in url. It is made to do so via Front end href
Returns:
response: JSON object
On Success \n
response = {
'result': 'done'
}
\n
On Fail:\n
response = {
'result': 'error'
}
\n
"""
if not current_user.is_authenticated:
print('not logged in')
return redirect(url_for('login'))
content = None
data = None
data = Project.from_user(current_user.user_id)
project_specific_data = []
html = None
titles = None
if Project.check_auth(current_user.user_id, int(project_id)):
project_specific_data = Project.get_one(current_user.user_id,
int(project_id))
if project_specific_data[0]['model_available']:
return jsonify(result='trained')
q.enqueue(DLModel.train_model,
project_specific_data[0]['dataset'][0]['name'],
int(project_id), app.config['UPLOAD_FOLDER'])
Database.update_one(collection='projects',
query=[{
'project_id': int(project_id)
}, {
"$set": {
"in_training": True
}
}])
return jsonify(result='done')
else:
return jsonify(result='error')
def update():
form = CourseForm()
if form.validate_on_submit():
q.enqueue(main_function, form.class_name.data, current_user.email,
form.url.data, int(form.seats.data))
flash('Congratulations course has been tracked!')
return redirect(url_for('index'))
return render_template('update.html', title='update', form=form)
def gym():
form = GymForm()
if form.validate_on_submit():
q.enqueue(update_loop, form.class_name.data, form.url.data,
current_user.email)
flash('Congratulations gym has been tracked!')
return redirect(url_for('index'))
return render_template('gym.html', title='gym', form=form)
def send_subscription_emails(gallery):
gallery_category_uuids = gallery.category_uuids()
if gallery_category_uuids:
subscription_uuids = list(set([s.subscription_uuid for s in SubscriptionCategory.get_list(category_uuid=gallery_category_uuids)]))
subscriptions = Subscription.get_list(dead=False, verified=True, uuid=subscription_uuids)
else:
subscriptions = Subscription.get_list(dead=False, verified=True)
for subscription in subscriptions:
q.enqueue(send_subscription_email, subscription, gallery)
def redirector(short_route):
url = Url.query.filter_by(short_route=short_route).first()
if url:
q.enqueue(get_ip_data, url.short_route, request.remote_addr)
destination = url.original_url
return redirect(destination, 301)
return redirect(request.host_url)
def mutate(self, info):
with session_scope() as db_session:
user = current_user._get_current_object()
if not current_user.is_authenticated:
raise GraphQLError(_("You must be signed in to do that."))
if user.verified:
raise GraphQLError(_("Your account is already verified."))
token = encode_token(user.email, verify_email_salt)
verify_url = generate_url("verify_email.verify_email", token)
template = template_env.get_template("verify_email.html")
content = template.render(display_name=user.username,
verify_url=verify_url)
q.enqueue(send_email, user.email,
_("Verify your DofusLab account"), content)
return ResendVerificationEmail(ok=True)
def api_print():
return_dict = {'success': False, 'print_material_ids': []}
# check for printer on
if not is_printer_on(printer): # negation for testing
# get labels
labels = jsonToLabels(request.get_json())
# for each sent to queue
for label in labels:
q.enqueue(print_task, printer, label, description=label.id)
return_dict['print_material_ids'].append(label.id)
return_dict['message'] = 'printer online!'
return_dict['success'] = True
return return_dict, 200
def bakground_tasks():
if request.args.get("n"):
job = q.enqueue(tasks.background_task, request.args.get('n'))
return f" Task {job.id} added to the queue at {job.enqueued_at} {job.result}"
return "No value for count provided"
def post(self):
args = self.reqparse.parse_args()
payload = {
'email': args.get('email'),
'message': args.get('message'),
'ip_addr': request.remote_addr
}
q.enqueue(add_message, payload)
if check_email(payload['email']):
mail_payload = {
'email': payload.get('email'),
'message': payload.get('message')
}
q.enqueue(send_email, **mail_payload)
return make_response({'success': True}, 200)
def tasks():
req = request.form
if req:
url = req.get('url')
task = q.enqueue(count_words, url)
jobs = q.jobs
q_len = len(q)
message = f"Task queued at {task.enqueued_at.strftime('%a, %d %b %Y %H:%M:%S')}. {q_len} jobs queued"
return render_template("public/tasks.html", jobs=jobs, message=message)
def add_task():
jobs = q.jobs
message = None
if request.args:
url = request.args.get('url')
task = q.enqueue(count_words, url)
jobs = q.jobs
q_len = len(q)
message = f"Task queued at {task.enqueued_at.strftime('%a, %d %b %Y %H:%M:%S')}. {q_len} jobs queued"
return render_template('public/task.html', message=message, jobs=jobs)
def upload_image():
message = None
if request.method == "POST":
image = request.files["image"]
image_dir_name = secrets.token_hex(16)
os.mkdir(
os.path.join(os.path.dirname(__file__),
app.config["UPLOAD_DIRECTORY"], image_dir_name))
image.save(
os.path.join(os.path.dirname(__file__),
app.config["UPLOAD_DIRECTORY"], image_dir_name,
image.filename))
image_dir = os.path.join(os.path.dirname(__file__),
app.config["UPLOAD_DIRECTORY"],
image_dir_name)
q.enqueue(create_image_set, image_dir, image.filename)
flash("Image uploaded and sent for resizing", "success")
message = f"/image/{image_dir_name}/{image.filename.split('.')[0]}"
return render_template("public/upload_image.html", message=message)
def mutate(self, info, **kwargs):
if current_user.is_authenticated:
raise GraphQLError(_("You are already logged in."))
email = kwargs.get("email")
user = ModelUserAccount.find_by_email(email)
auth_error = GraphQLError(
_("We could not find an account with that email."))
if not user:
raise auth_error
if not user.verified:
raise GraphQLError(_("Please verify your email first."))
token = encode_token(user.email, reset_password_salt)
reset_password_url = "{}reset-password?token={}".format(
base_url, token)
template = template_env.get_template("reset_password.html")
content = template.render(display_name=user.username,
reset_password_url=reset_password_url)
q.enqueue(send_email, user.email, _("Reset your DofusLab password"),
content)
return RequestPasswordReset(ok=True)
def resized_images():
if request.method == 'POST':
image = request.files['image']
image_dir_name = secrets.token_hex(16)
os.mkdir(os.path.join(app.config['IMAGE_UPLOADS'], image_dir_name))
image.save(
os.path.join(app.config['IMAGE_UPLOADS'], image_dir_name,
image.filename))
image_dir = os.path.join(app.config['IMAGE_UPLOADS'], image_dir_name)
jobs = q.enqueue(image_task, image_dir, image.filename)
flash("Image Uploaded and sent for resizing", "success")
message = f"/image/{image_dir_name}/{image.filename.split('.')[0]}"
return render_template("public/upload_resize_img.html")
def demo():
if not 'userid' in session:
session['userid'] = str(uuid.uuid4())
session['jobs'] = []
session.permanent = True
# Create a job
job_args = [session['userid']]
job_meta = {'name': 'Demo', 'status': 'Setting up data...', 'type': 'A', 'notfound': []}
job = q.enqueue(create_demo_job, args=job_args, meta=job_meta, timeout=60*60)
session['jobs'].append(job.id)
return jsonify(job_meta), 202, {'Location': '/jobs/{}'.format(job.id)}
def post(self):
args = self.reqparse.parse_args()
# Create user ID if first request
if not 'userid' in session:
session['userid'] = str(uuid.uuid4())
session['jobs'] = []
session.permanent = True
# Only one assembly allowed for now
job_types = [q.fetch_job(job_id).meta['type'] for job_id in session['jobs']]
if 'A' in job_types:
return {'message': 'You already have an assembly job running.'}, 403, {}
if args.contigs.filename == '':
return {'message': 'Please provide an assembly file.'}, 403, {}
# Create assembly
name = args.name or 'Assembly'
assembly = Assembly(name=name,
ip=request.headers.get('X-Forwarded-For', request.remote_addr),
userid=session['userid'],
email=args.email,
busy=True,
submit_date=datetime.utcnow(),
has_fourmerfreqs=args.fourmers,
genes_searched=args.hmmer)
db.session.add(assembly)
db.session.commit()
fasta_path = os.path.join(app.config['BASEDIR'],
'data/assemblies',
'{}.fa'.format(assembly.id))
with open(fasta_path, 'wb') as f:
args.contigs.save(f)
if args.coverage.filename != '':
coverage_file = tempfile.NamedTemporaryFile(delete=False)
args.coverage.save(coverage_file)
coverage_file.close()
# Send job
job_args = [assembly, fasta_path, args.fourmers, args.hmmer, args.email]
job_meta = {'name': name, 'status': 'pending', 'type': 'A', 'notfound': []}
if args.coverage.filename != '':
job_args.append(coverage_file.name)
job = q.enqueue(save_assembly_job, args=job_args, meta=job_meta,
timeout=60*60*24)
session['jobs'].append(job.id)
return job_meta, 202, {'Location': '/jobs/{}'.format(job.id)}
def process_new_user(db, user: User) -> User:
db.session.add(user)
db.session.commit()
# send welcome email
send_welcome_message(user.id)
job = q.enqueue(send_welcome_message, user.id)
welcome_email_task = Task(id=job.id, user=user, name="welcome_email")
db.session.add(welcome_email_task)
db.session.commit()
# add task to send email in 10 days
return user
def post(self):
message = request.json.get('message')
job = q.enqueue(count_word, message)
print("Task in job: {} add to queue at {}".format(
job.id, job.enqueued_at))
# print("status: {}".format(job.status))
print("func_name: {}".format(job.func_name))
print("args: {}".format(job.args))
print("kwargs: {}".format(job.kwargs))
print("result: {}".format(job.result))
print("started_at: {}".format(job.started_at))
print("ended_at: {}".format(job.ended_at))
print("execute_info: {}".format(job.exc_info))
return jsonify({"count": job.result})
def consume():
while True:
papers = db.session.query(Paper).filter((Paper.in_queue == None)\
| (Paper.in_queue == 0)).all()
# push paper to queue
#for paper in papers[1:10]:
for paper in papers:
job = q.enqueue(crawler, paper.id, paper.url)
time.sleep(3)
result = job.result
if result:
print(result)
keywords = result['keywords']
organizations = result['organizations']
authors = result['authors']
record_keywords = []
record_organizations = []
record_authors = []
if keywords:
for keyword in keywords:
keyword = get_or_create(db.session,
Keyword,
keyword=keyword)
record_keywords.append(keyword)
db.session.add(keyword)
else:
record_keywords = []
for organization in organizations:
organization = get_or_create(db.session,
Organization,
organization=organization)
record_organizations.append(organization)
db.session.add(organization)
for author in authors:
author = get_or_create(db.session, Author, author=author)
record_authors.append(author)
db.session.add(author)
paper.description = result['abstract']
paper.year = result['year']
paper.in_queue = 1
paper.keywords = record_keywords
paper.organizations = record_organizations
paper.authors = record_authors
db.session.add(paper)
db.session.commit()
def post(self):
args = self.reqparse.parse_args()
bin = Bin.query.get_or_404(args.bin)
if session['userid'] != bin.bin_set.assembly.userid:
abort(403)
job_args = [args.bin, args.rank, args.taxon]
job_meta = {'bin': bin.id, 'binSet': bin.bin_set.id,
'assembly': bin.bin_set.assembly.id, 'type': 'C'}
job = q.enqueue(run_hmmer_job, meta=job_meta, args=job_args,
timeout=60*30)
session['jobs'].append(job.id)
return job_meta, 202, {'Location': '/jobs/{}'.format(job.id)}
def upload_image():
if request.method == 'POST':
result = {}
# check if the post request has the file part
if 'file' not in request.files:
result['response'] = 'No file part'
return jsonify(result)
#Check that file type jpg
for f in request.files.getlist('file'):
if not allowed_file(f.filename):
result['responce'] = 'Only JPG file can be used'
return jsonify(result)
else:
new_file_folder = uuid.uuid4().hex
os.makedirs(UPLOAD_FOLDER + "/" + new_file_folder)
for f in request.files.getlist('file'):
filename = secure_filename(f.filename)
f.save(os.path.join(UPLOAD_FOLDER, new_file_folder, filename))
# Add new image folder
f_img = os.path.join(UPLOAD_FOLDER, new_file_folder)
#job queue, add RUN function to thread
job = q.enqueue(run, f_img)
if job.status == "failed":
result['response'] = 'Job failed'
return jsonify(result)
while job.result is None:
pass
else:
result_img = job.result
imagegroup = ImageGroup()
db.session.add(imagegroup)
db.session.commit()
for i in result_img:
info = job.result[i]
filename = (info['name'])
count = info["count"]
img_data = info['path']
new_file = Images(img_filename=filename,
counter=count,
img_data=img_data,
imagegroup_id=imagegroup.id)
db.session.add(new_file)
db.session.commit()
#session['result'] = result_img
return redirect(
url_for("images.results", imagegroup=imagegroup.id))
return ('', 204)
def url():
if flask.request.method == "POST":
submited_url = flask.request.form["url"]
url_count = q.enqueue(count_words_at_url,
result_ttl=10,
ttl=10,
args=(submited_url, ))
response = 200
if (url_count is not None or url_count["error"] is not None):
reponse = 404
return render_template("submit_url.html"), response, {
'ContentType': 'application/json',
'extra': url_count
}
return render_template("submit_url.html")
def add_task():
jobs = q.jobs # Get a list of jobs in the queue
message = None
if request.args: # Only run if a query string is sent in the request
url = request.args.get(
"url") # Gets the URL coming in as a query string
task = q.enqueue(count_words, url) # Send a job to the task queue
jobs = q.jobs # Get a list of jobs in the queue
q_len = len(q) # Get the queue length
message = f"Task queued at {task.enqueued_at.strftime('%a, %d %b %Y %H:%M:%S')}. {q_len} jobs queued"
return render_template("add_task.html", message=message, jobs=jobs)
def add_task():
jobs = q.jobs
message = None
url = None
if request.args:
url = request.args.get("url")
task = q.enqueue(tasks.count_words, url)
jobs = q.jobs
q_len = len(q)
message = f"Task queued at {task.enqueued_at.strftime('%a, %d %b %Y %H:%M:%S')}.{q_len}"
return render_template("add_task.html",
message=message,
jobs=jobs,
url=url)
def add_task():
"""
Route to a page where usrs send word-scraping requests.\n
RQ queues up a task defined in tasks.py
"""
jobs = q.jobs
message = None
if request.args:
if request.args.get('url'):
url = request.args.get('url')
task = q.enqueue(count_words, url)
jobs = q.jobs
q_length = len(q)
message = f"Task queued at {task.enqueued_at.strftime('%a %d %b %Y %H:%M')}. {q_length} Jobs Queued"
# redirects to "/result" route and pass on "url"
return redirect(url_for(".show_result", url=url))
return render_template('add_task.html', message=message, jobs=jobs)
def post(self, assembly_id):
assembly = user_assembly_or_404(assembly_id)
args = self.reqparse.parse_args()
name = args.name or 'Binset'
if args.bins.filename != '':
bin_file = tempfile.NamedTemporaryFile(delete=False)
args.bins.save(bin_file)
bin_file.close()
# Send job
job_args = [name, assembly.id]
if args.bins.filename != '':
job_args.append(bin_file.name)
job_meta = {'type': 'B', 'name': name, 'assembly': assembly.id}
job = q.enqueue(save_bin_set_job, args=job_args, meta=job_meta)
session['jobs'].append(job.id)
return job_meta, 202, {'Location': '/jobs/{}'.format(job.id)}
def create_checks():
if request.is_json:
data = request.get_json()
if check_service.is_created(data['order_id']):
response = {'error': 'Для данного заказа уже созданы чеки'}
return jsonify(response), 401
printers = printer_service.get_printers(data['point_id'])
if printers:
job = q.enqueue(generate, data=data)
print(f'Task ({job.id}) added to queue at {job.enqueued_at}')
response = {'ok': 'Чеки успешно созданы'}
return jsonify(response)
response = {'msg': 'Для данной точки не настроено ни одного принтера'}
return jsonify(response), 401
return jsonify({'msg': 'no json recivied'})
def index():
if request.method == 'POST':
# check if the post request has the file part
result = {}
# check if the post request has the file part
if 'file' not in request.files:
result['response'] = 'No file part'
return jsonify(result)
#Check that file type jpg
for f in request.files.getlist('file'):
if not allowed_file(f.filename):
result['responce'] = 'Only JPG file can be used'
return jsonify(result)
else:
new_file_folder = uuid.uuid4().hex
os.makedirs(UPLOAD_FOLDER + "/" + new_file_folder)
for f in request.files.getlist('file'):
filename = secure_filename(f.filename)
f.save(os.path.join(UPLOAD_FOLDER, new_file_folder, filename))
# Add new image folder
f_img = os.path.join(UPLOAD_FOLDER, new_file_folder)
#job queue, add RUN function to thread
job = q.enqueue(run, f_img)
if job.status == "failed":
result['response'] = 'Job failed'
return jsonify(result)
while job.result is None:
pass
else:
result_img = job.result
#print(result_img[1])
session[
'result'] = result_img #Add dict of all images with each count values to session
#return redirect(url_for("result", count=count))
return redirect(url_for("images.result"))
#return render_template("index.html")
return ('', 204)
def task():
job = q.enqueue(ratingscrape.getRatings, userurl)
return f"Task ({job.id}) added to queue at {job.enqueued_at}"
def task():
if request.args.get("n"):
job = q.enqueue(background_task, request.args.get("n"))
return f"Task ({job.id}) added to queue at {job.enqueued_at}"
return "No value for count provided"
