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"