def create_app(): app = Flask(__name__) dropzone = Dropzone(app) app.config['SECRET_KEY'] = 'supersecretkeygoeshere' # Dropzone settings app.config['DROPZONE_UPLOAD_MULTIPLE'] = True app.config['DROPZONE_ALLOWED_FILE_CUSTOM'] = True app.config['DROPZONE_ALLOWED_FILE_TYPE'] = 'image/*' app.config['DROPZONE_REDIRECT_VIEW'] = 'results' # Uploads settingsv app.config['UPLOADED_PHOTOS_DEST'] = 'C:/lungapp/abiapp/static/uploads' photos = UploadSet('photos', IMAGES) configure_uploads(app, photos) patch_request_class(app) # set maximum file size, default is 16MB app.config['SECRET_KEY'] = '9OLWxND4o83j4K4iuopO' app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///db.sqlite' db.init_app(app) login_manager = LoginManager() login_manager.login_view = 'auth.login' login_manager.init_app(app) @app.route('/upload', methods=['GET', 'POST']) def upload(): # set session for image results #app.config['UPLOADED_PHOTOS_DEST'] = 'C:/Users/Abishai/OneDrive/Desktop/abiapp/static/uploads/test' if "file_urls" not in session: session['file_urls'] = [] # list to hold our uploaded image urls file_urls = session['file_urls'] # handle image upload from Dropszone if request.method == 'POST': file_obj = request.files for f in file_obj: file = request.files.get(f) # save the file with to our photos folder filename = photos.save(file, name=file.filename) # append image urls file_urls.append(photos.url(filename)) session['file_urls'] = file_urls return "uploading..." # return dropzone template on GET request return render_template('upload.html') @app.route('/results') def results(): # redirect to home if no images to display if "file_urls" not in session or session['file_urls'] == []: return redirect(url_for('upload')) # set the file_urls and remove the session variable file_urls = session['file_urls'] session.pop('file_urls', None) return render_template('results.html', file_urls=file_urls) import os import io import json import torch import torch.nn.functional as F from PIL import Image from torch import nn from torchvision import transforms as T from torchvision import models @app.route('/detect', methods=['GET', 'POST']) def detect(): files_list = os.listdir(app.config['UPLOADED_PHOTOS_DEST']) return render_template('detect.html', files_list=files_list) @app.route('/detectres/<imgg>', methods=['GET', 'POST']) def detectres(imgg): idx2label = ('Atelectasis', 'Cardiomegaly', 'Consolidation', 'Edema', 'Effusion', 'Emphysema', 'Fibrosis', 'Hernia', 'Infiltration', 'Mass', 'Nodule', 'Normal Study', 'Pleural_thickening', 'Pneumonia', 'Pneumothorax') PATH = 'C:\\lungapp\\lungdiseasemodel.pt' num_classes = 15 resnet = models.resnet18(pretrained=False) resnet.conv1 = nn.Conv2d(1, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3)) resnet.fc = nn.Linear(in_features=512, out_features=num_classes, bias=True) resnet.load_state_dict(torch.load(PATH)) resnet.eval() file_url = 'C:\\lungapp\\abiapp\\static\\uploads\\' + imgg image = open(file_url, 'rb').read() target_size = (224, 224) image = Image.open(io.BytesIO(image)) image = T.Resize(target_size)(image) image = T.ToTensor()(image) # Convert to Torch.Tensor and normalize. image = T.Normalize([0.449], [0.226])(image) # Add batch_size axis. image = image[None] ####if use_gpu: ####image = image.cuda() image = torch.autograd.Variable(image, volatile=True) data = {"success": False} outputs = resnet(image) _, pred = torch.max(outputs.data, 1) data['predictions'] = list() r = ''.join('%5s' % idx2label[pred]) data = r ress = data ress = ''.join(str(e) for e in ress) print(ress) return render_template("detectres.html", ress=ress) from .models import User @login_manager.user_loader def load_user(user_id): # since the user_id is just the primary key of our user table, use it in the query for the user return User.query.get(int(user_id)) # blueprint for auth routes in our app from .auth import auth as auth_blueprint app.register_blueprint(auth_blueprint) # blueprint for non-auth parts of app from .main import main as main_blueprint app.register_blueprint(main_blueprint) return app
def CreateWallApp(): app = WallApp(static_folder='assets', static_url_path='/assets') app.config.from_object(__name__ + '.ConfigClass') try: app.config.from_object('local_settings') except: pass # Use for Frontend debug # CORS(app, resources={r"/api/*": {"origins": "*"}}) Compress(app) Cache(app) babel = Babel(app) login = LoginManager(app) def redirect_dest(fallback): dest = request.args.get('next') try: dest_url = url_for(dest) except: return redirect(fallback) return redirect(dest_url) @login.unauthorized_handler def handle_needs_login(): flash("You have to be logged in to access this page.") return redirect(url_for('login', next=request.endpoint)) @app.route("/login", methods=["GET", "POST"]) def login(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] user = User.query.filter(or_(User.username == username, User.email == username)).first() if user is None or not user.check_password(password): flash("Sorry, but you could not log in.") redirect(url_for('home_page')) else: next = request.form['next'] login_user(user, remember=True) return redirect(next) else: next = request.args.get('next') return render_template("login.html", next=next) login.login_view = 'login' @babel.localeselector def get_locale(): return 'ru' app.dropzone = Dropzone(app) app.photos = UploadSet('photos', IMAGES) configure_uploads(app, app.photos) patch_request_class(app) # set maximum file size, default is 16MB @app.template_filter('data_fmt') def data_fmt(filename): datatypes = {'image': 'gif,ico,jpe,jpeg,jpg,png,svg,webp'} t = 'unknown' for type, exts in datatypes.items(): if filename.split('.')[-1] in exts: t = type return t @app.template_filter('icon_fmt') def icon_fmt(filename): icontypes = {'fa-picture-o': 'gif,ico,jpe,jpeg,jpg,png,svg,webp'} i = 'fa-file-o' for icon, exts in icontypes.items(): if filename.split('.')[-1] in exts: i = icon return i @app.route('/') def home_page(): users = db.session.query(func.count(User.id)).scalar() files = db.session.query(func.count(File.id)).scalar() classes = db.session.query(func.count(ObjectClass.id)).scalar() marked = db.session.query(File).filter(File.processed == True).count() is_logedin = current_user.is_authenticated return render_template("index.html", marked=str(marked), classes=str(classes), files=str(files), users=str(users), is_logedin=is_logedin) @app.route('/images_page') @login_required def images_page(): return render_template('images_page.html') @app.route("/logout") @login_required def logout(): logout_user() return redirect(url_for('home_page')) api = Api(app) class Files(Resource): def get(self, page): pglen = 10 record_query = File.query \ .filter(File.updated_at <= lessthenNow()) \ .paginate(int(page), pglen, False) files = record_query.items contents = [] total = {'files': len(files), 'pglen': pglen} for file in files: filepath = app.photos.url(file.image) info = {} info['name'] = file.image info['width'] = file.width info['height'] = file.height info['pcsd'] = file.processed info['url'] = filepath info['type'] = 'file' contents.append(info) return {'contents': contents, 'total': total} class ObjectClasses(Resource): def get(self): contents = [] items = ObjectClass.query.all() for tag in items: info = {} info['value'] = tag.name info['color'] = "rgb(" + str(tag.r) + ", " + str(tag.g) + ", " + str(tag.b) + ")" contents.append(info) return {'tags': contents} class ImageDescriptor(Resource): def __init__(self, session, **kwargs): super(Resource, self).__init__(**kwargs) self.session = session self.parser = reqparse.RequestParser() self.parser.add_argument('description') def get(self, name): try: file = self.session.query(File) \ .filter(File.image == name).one() return json.dumps({'status': 'ok', 'url': app.photos.url(file.image), 'description': file.description}) except MultipleResultsFound: return json.dumps({'status': 'error', 'error': 'multiple files'}) except NoResultFound: return json.dumps({'status': 'error', 'error': 'no such file'}) def post(self, name): try: file = self.session.query(File) \ .filter(File.image == name).one() args = self.parser.parse_args() descr = args['description'] if not descr: return file.description = descr file.processed = True self.session.commit() return json.dumps({'status': 'ok'}) except MultipleResultsFound: return json.dumps({'status': 'error', 'error': 'multiple files'}) except NoResultFound: return json.dumps({'status': 'error', 'error': 'no such file'}) api.add_resource(Files, '/api/v1/FilesREST/<page>') api.add_resource(ImageDescriptor, '/api/v1/ImageREST/<name>', resource_class_kwargs={'session': db.session}) api.add_resource(ObjectClasses, '/api/v1/ObjectClassesREST') return app
""" ############### app = Flask(__name__) app.secret_key = '&#*OnNyywiy1$#@' app.config.from_pyfile('app.cfg') HOST = '0.0.0.0' PORT = 5000 DEBUG = False ### DATABASE DB = TinyMongoClient().blog initialize(DB) ### FILE UPLOADS PARAMETERS dropzone = Dropzone() dropzone.init_app(app) # UPLOAD FOLDER will have to change based on your own needs/deployment scenario BASE_DIR = os.path.dirname(os.path.abspath(__file__)) UPLOAD_FOLDER = os.path.join(BASE_DIR, './uploads') app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER ALLOWED_EXTENSIONS = set(['txt', 'pdf', 'png', 'jpg', 'jpeg', 'gif']) @app.before_request def before_request(): """tasks before request is executed""" g.db = DB g.username = session.get('username') g.is_authenticated = session.get('is_authenticated')
app = Flask(__name__) app.secret_key = b'_5#y2L"F4Q8z\n\xec]/' # set secret key app.config.update( UPLOADED_PATH=os.path.join(basedir, 'uploads'), # Flask-Dropzone config: DROPZONE_ALLOWED_FILE_CUSTOM = True, # Allows for custom file types (ie; torrent files) DROPZONE_MAX_FILE_SIZE = 1, # 1mb file size DROPZONE_FILE_TOO_BIG="That file is too large. 1mb max...", # bad boy DROPZONE_ALLOWED_FILE_TYPE = 'image/*, .pdf, .txt, .torrent', DROPZONE_MAX_FILES=30 # num of max files ) dropzone = Dropzone(app) # init upload field @app.route('/p') def x(): print(request.cookies) return "not good" @app.route('/', methods=['POST', 'GET']) def home(): # If post, that means someone added files, put them in the correct dir... if request.method == 'POST':
img = Blueprint('img', __name__) basedir = os.path.abspath(os.path.dirname(__file__)) #ディレクトリ名を取得 app = Flask(__name__) with app.app_context(): current_app.config.update( UPLOADED_PATH=os.path.join(basedir, ''), #絶対パス # Flask-Dropzone config: DROPZONE_ALLOWED_FILE_TYPE='image', DROPZONE_MAX_FILE_SIZE=3, DROPZONE_MAX_FILES=30, ) dropzone = Dropzone(current_app) """ FunctionName : upload Data : 2020/07/21 Designer : 野田啓介 Function : レシート画像をアップロードする Entry : userID --- ユーザーID Return : SearchOrderThingメソッドにリダイレクトする userID --- ユーザーID fileName --- レシート画像のファイル名 """ @img.route('/upload/<userID>', methods=['GET', 'POST']) def upload(userID):
"""Flask application entrypoint""" from __future__ import absolute_import, division, print_function import flask_monitoringdashboard as dashboard from flask import Flask from flask_compress import Compress from flask_cors import CORS from flask_dropzone import Dropzone from deepcell_label import config from deepcell_label.blueprints import bp from deepcell_label.models import db compress = Compress() # pylint: disable=C0103 dropzone = Dropzone() # pylint: disable=C0103 class ReverseProxied(object): """Enable TLS for internal requests. Found in: https://stackoverflow.com/questions/30743696 """ def __init__(self, app): self.app = app def __call__(self, environ, start_response): scheme = environ.get('HTTP_X_FORWARDED_PROTO') if scheme: environ['wsgi.url_scheme'] = scheme return self.app(environ, start_response)
import cv2 import numpy as np from keras.preprocessing import image from keras.models import model_from_json # Imports PIL module from PIL import Image import tensorflow as tf import pickle ##################################################### from flask_cors import CORS, cross_origin import requests from bs4 import BeautifulSoup from newspaper import Article ##################################################### app = Flask(__name__) dropzone = Dropzone(app) # INIT DROPZONE FOR FILE UPLOAD #run_with_ngrok(app) cors = CORS(app) app.config['CORS_HEADERS'] = 'Content-Type' """ LOADING DEVNET -- """ cmfdModel = create_CMFD_model('./pretrained_devNet.hd5') print("------- DevNet Loaded from Disk --------") # load model from JSON file with open("modela.json", "r") as json_file: loaded_model_json = json_file.read() loaded_model = model_from_json(loaded_model_json) # load weights into the new model loaded_model.load_weights("modelNNa.h5") print("-------- Model loaded from disk --------")
from flask_dropzone import Dropzone from flask_uploads import UploadSet, configure_uploads, IMAGES, patch_request_class import logging import random import time from PIL import Image import requests, os from io import BytesIO from predict import TransferModel from settings import * app = Flask(__name__) dropzone = Dropzone(app) # print(os.getcwd()) # Uploads settings app.config['UPLOADED_PHOTOS_DEST'] = os.getcwd() + '/transfer/uploads' app.config['DROPZONE_UPLOAD_MULTIPLE'] = False app.config['DROPZONE_ALLOWED_FILE_CUSTOM'] = True app.config['DROPZONE_ALLOWED_FILE_TYPE'] = 'image/*' app.config['DROPZONE_REDIRECT_VIEW'] = 'results' photos = UploadSet('photos', IMAGES) configure_uploads(app, photos) patch_request_class(app) # set maximum file size, default is 16MB # model resnet_model = TransferModel('transfer/', 'resnet152_final_model.pt') hrnet_model = TransferModel('transfer/', 'hrnet_final_model.pt')
def CreateWallApp(): app = WallApp(static_folder='assets', static_url_path='/assets') app.config.from_object(__name__ + '.ConfigClass') try: app.config.from_object('local_settings') except: pass # Use for Frontend debug CORS(app, resources={r"/api/*": {"origins": "*"}}) Compress(app) Cache(app) babel = Babel(app) login = LoginManager(app) @login.unauthorized_handler def handle_needs_login(): flash("You have to be logged in to access this page.") return redirect(url_for('login', next=request.endpoint)) @app.route("/login", methods=["GET", "POST"]) def login(): if request.method == 'POST': username = request.form['username'] password = request.form['password'] user = User.query.filter( or_(User.username == username, User.email == username)).first() if user is None or not user.check_password(password): flash("Sorry, but you could not log in.") redirect(url_for('home_page')) else: next = request.form['next'] login_user(user, remember=True) return redirect(next) else: next = request.args.get('next') return render_template("login.html", next=next) login.login_view = 'login' @babel.localeselector def get_locale(): return 'ru' app.dropzone = Dropzone(app) app.photos = UploadSet('photos', IMAGES) configure_uploads(app, app.photos) patch_request_class(app) @app.route('/') def home_page(): users = db.session.query(func.count(User.id)).scalar() images = db.session.query(func.count(Image.id)).scalar() is_logedin = current_user.is_authenticated return render_template("index.html", files=str(images), users=str(users), is_logedin=is_logedin) @app.route('/images_page') @login_required def images_page(): return render_template('images_page.html') @app.route("/logout") @login_required def logout(): logout_user() return redirect(url_for('home_page')) api = Api(app) class Images(Resource): def get(self, page): pglen = 10 record_query = Image.query \ .filter(Image.updated_at <= datetime.now()) \ .paginate(int(page), pglen, False) files = record_query.items contents = [] total = {'files': len(files), 'pglen': pglen} for file in files: filepath = app.photos.url(file.image) info = {} info['name'] = file.image info['width'] = file.width info['height'] = file.height info['url'] = filepath info['type'] = 'file' contents.append(info) return {'contents': contents, 'total': total} api.add_resource(Images, '/api/v1/FilesREST/<page>') return app
def create_app(config_filename=None): # create and configure the app app = Flask(__name__, instance_relative_config=True) basedir = os.path.abspath(os.path.dirname(__file__)) app.config.update( UPLOADED_PATH=os.path.join(basedir, 'static'), # Flask-Dropzone config: DROPZONE_ALLOWED_FILE_TYPE='image', DROPZONE_MAX_FILE_SIZE=2, DROPZONE_MAX_FILES=2, DROPZONE_UPLOAD_ON_CLICK=True, ) dropzone = Dropzone(app) result = {} app.config["DEBUG"] = True if config_filename: app.config.from_pyfile(config_filename) def similarity(f1_name, f2_name): try: f1 = os.path.join(app.config['UPLOADED_PATH'], f1_name) f2 = os.path.join(app.config['UPLOADED_PATH'], f2_name) id = f1_name[:8] + f2_name[:8] + ".png" pixel_match_file = os.path.join(app.config['UPLOADED_PATH'], "PM_" + id) feature_match_file = os.path.join(app.config['UPLOADED_PATH'], "FM_" + id) feature_diff_file1 = os.path.join(app.config['UPLOADED_PATH'], "FD1_" + id) feature_diff_file2 = os.path.join(app.config['UPLOADED_PATH'], "FD2_" + id) catagory_match_file = os.path.join(app.config['UPLOADED_PATH'], "CM_" + id) app.logger.debug('comparing %s with %s', f1, f2) pd = simple_pixel_diff(f1, f2, pixel_match_file) app.logger.debug('pixel matching score: %f', pd) feature_match_score = feature_matching(f1, f2, feature_match_file) app.logger.debug('feature matching score: %d', feature_match_score) feature_diff_score = feature_diff(f1, f2, feature_diff_file1, feature_diff_file2) category1 = img_classification(f1) category2 = img_classification(f2) euclidean_distance, cosine_distance = img_similarity(f1, f2) return { 'f1': f1_name, 'f2': f2_name, 'success': True, 'pixel_match_score': pd, 'pixel_match_img': "PM_" + id, 'feature_match_score': feature_match_score, 'feature_match_img': "FM_" + id, 'euclidean_distance': euclidean_distance, 'cosine_distance': cosine_distance, 'category_match_img': "CM_" + id, 'feature_diff_score': feature_diff_score, 'feature_diff_img1': "FD1_" + id, 'feature_diff_img2': "FD2_" + id, "category1": category1, "category2": category2 } except: traceback.print_exc() return {'success': False, 'utterances': None} @app.route('/', methods=['GET']) def home(): return render_template('index.html') @app.route('/upload', methods=['POST']) def upload(): files = [] if request.method == 'POST': for key, f in request.files.items(): if key.startswith('file'): name = random_filename(f.filename) f.save(os.path.join(app.config['UPLOADED_PATH'], name)) files.append(name) app.logger.info('saving %s', f.filename) app.logger.debug('received %d', len(files)) return jsonify({"files": files}) @app.route('/diff', methods=['GET']) def completed(): f1 = request.args.get('f1') f2 = request.args.get('f2') res = similarity(f1, f2) return render_template('response.html', res=res) return app
def _init_plugins(app): CKEditor(app) Dropzone(app) Session(app)
from flask_avatars import Avatars from flask_bootstrap import Bootstrap from flask_dropzone import Dropzone from flask_login import LoginManager, AnonymousUserMixin from flask_mail import Mail from flask_moment import Moment from flask_sqlalchemy import SQLAlchemy from flask_wtf import CSRFProtect from flask_whooshee import Whooshee bootstrap = Bootstrap() db = SQLAlchemy() login_manager = LoginManager() mail = Mail() dropzone = Dropzone() # 图片上传 moment = Moment() whooshee = Whooshee() # 全文搜索 avatars = Avatars() # 头像功能 csrf = CSRFProtect() # 安全模块 @login_manager.user_loader def loader_user(user_id): from photosocial.models import User user = User.query.get(int(user_id)) return user login_manager.login_view = 'auth.login' login_manager.login_message_category = 'warning' login_manager.refresh_view = 'auth.re_authenticate'
from flask_dropzone import Dropzone from flask_login import LoginManager, AnonymousUserMixin from flask_mail import Mail from flask_moment import Moment from flask_sqlalchemy import SQLAlchemy from flask_whooshee import Whooshee from flask_wtf import CSRFProtect from flask_ckeditor import CKEditor from flask_debugtoolbar import DebugToolbarExtension from flask_caching import Cache bootstrap = Bootstrap() db = SQLAlchemy() login_manager = LoginManager() mail = Mail() dropzone = Dropzone() # 在扩展模块中实例化扩展类 moment = Moment() whooshee = Whooshee() avatars = Avatars() csrf = CSRFProtect() ckeditor = CKEditor() toolbar = DebugToolbarExtension() cache = Cache() @login_manager.user_loader def load_user(user_id): from albumy.models import User user = User.query.get(int(user_id)) return user
MAIL_DEFAULT_SENDER='default mail sender', SQLALCHEMY_COMMIT_ON_TEARDOWN=True)) # use login manager to manage session login_manager = LoginManager() login_manager.anonymous_user = Anonymous login_manager.session_protection = 'strong' login_manager.login_view = 'index' login_manager.init_app(app=server) # csrf protection csrf = CSRFProtect() csrf.init_app(server) #flask dropzone dropzone = Dropzone() dropzone.init_app(server) server.config['DROPZONE_ENABLE_CSRF'] = True server.config['DROPZONE_ALLOWED_FILE_CUSTOM'] = True server.config[ 'DROPZONE_ALLOWED_FILE_TYPE'] = '.png, .jpg, .jpeg, .JPG, .pdf, .JPEG' server.config['DROPZONE_UPLOAD_MULTIPLE'] = False server.config['DROPZONE_PARALLEL_UPLOADS'] = 1 server.config['DROPZONE_MAX_FILES'] = 10 server.config['DROPZONE_MAX_FILE_SIZE'] = 10 @server.teardown_request def shutdown_session(exception=None): db_session.remove()
import time import os import ntpath import base64 import cv2 from flask import render_template, redirect, url_for, request, session, make_response from flask_dropzone import Dropzone from flask_uploads import UploadSet, configure_uploads, IMAGES, patch_request_class from app import app from app.smoothing import averaging_yourchoice, gaussian_yourchoice from app.sharp_image import pos_zero, pos_nonzero, neg_zero, neg_nonzero # from app.first_order_filter import prewitt_filter, sobel_filter from app.first_order_filter import prewitt_filter, sobel_filter from app.unsharp_mask import unsharp_mask #** DROPZONE = Dropzone(app) # Uploads settings app.config['UPLOADED_PHOTOS_DEST'] = os.getcwd() + '/uploads' PHOTOS = UploadSet('photos', IMAGES) configure_uploads(app, PHOTOS) patch_request_class(app) # set maximum file size, default is 16MB FILTER_DISPATCHER = { 'avg_smoothing': averaging_yourchoice, 'guass_smoothing': gaussian_yourchoice, 'laplacian_pos_zero': pos_zero, 'laplacian_pos_nonzero': pos_nonzero, 'laplacian_neg_zero': neg_zero, 'laplacian_neg_nonzero': neg_nonzero, 'first_order_prewitt': prewitt_filter, 'first_order_sobel': sobel_filter,
from flask_login import LoginManager from flask_migrate import Migrate from flask_redis import FlaskRedis from flask_sqlalchemy import SQLAlchemy from flask_uploads import UploadSet, IMAGES from flask_dropzone import Dropzone db = SQLAlchemy() login_manager = LoginManager() migrate = Migrate() # 普通的 Redis 连接池 rdb = FlaskRedis() # 缓存用 Redis 连接池 cache_rdb = FlaskRedis() photos = UploadSet('photos', IMAGES) drop_zone = Dropzone()
app = Flask(__name__, template_folder="./templates/", static_folder="./styles/") app.config.update({ "DROPZONE_ALLOWED_FILE_CUSTOM": True, "DROPZONE_ALLOWED_FILE_TYPE": ".csv", "DROPZONE_DEFAULT_MESSAGE": "Drag & drop or select your movie ratings", "DROPZONE_MAX_FILES": 1, "DROPZONE_MAX_FILE_SIZE": 10, "DROPZONE_REDIRECT_VIEW": "ratingsupload", "PERMANENT_SESSION_LIFETIME": timedelta(minutes=10), "SECRET_KEY": uuid.uuid4().hex, "SESSION_TYPE": "filesystem", }) Dropzone(app) Session(app) api = Api(app) api.add_resource(Home, "/") api.add_resource(About, "/about") api.add_resource(SearchBar, "/search-bar") api.add_resource(Autocomplete, "/_autocomplete") api.add_resource(RatingsUpload, "/ratings-upload") api.add_resource(AddSimilarMovie, "/add-similar-movie") api.add_resource(SimilarMovieFinder, "/similar-movie-finder") api.add_resource(RemoveSimilarMovie, "/remove-similar-movie/<uuid_>") api.add_resource(RatingsUploadNextMovie, "/ratings-upload-next-movie") api.add_resource(SimilarMovieFinderNext, "/similar-movie-finder-next") api.add_resource(RatingsUploadPreviousMovie, "/ratings-upload-previous-movie") api.add_resource(SimilarMovieFinderPrevious, "/similar-movie-finder-previous")
from collections import defaultdict from flask_dropzone import Dropzone from werkzeug.middleware.proxy_fix import ProxyFix from flask import Flask, request, send_file, render_template, abort, jsonify, redirect, url_for from flask_cors import CORS from flask_basicauth import BasicAuth from flasgger import Swagger import utils import worker import database application = Flask(__name__) dropzone = Dropzone(application) # application.config['DROPZONE_UPLOAD_MULTIPLE'] = True # application.config['DROPZONE_PARALLEL_UPLOADS'] = 3 DEVELOPMENT = os.environ.get('environment', 'production').lower() == 'development' if not DEVELOPMENT: # In some setups this proved to be necessary for url_for() to pick up HTTPS application.wsgi_app = ProxyFix(application.wsgi_app, x_proto=1) CORS(application) application.config['SWAGGER'] = { 'title': os.environ.get('APP_NAME', 'ifc-pipeline request API'),
def create_app(): app = Flask(__name__) app.config.from_object(__name__) # Check Configuration section for more details # And here: http://codeomitted.com/flask-session-aws-redis/ # From here: https://pythonhosted.org/Flask-Session/ app.config['SESSION_TYPE'] = 'redis' # Note: to work locally, 'redis' should be pointing to 127.0.0.1 in the hosts file app.config['SESSION_REDIS'] = redis.Redis(host='redis', port=6379) Session(app) app.config.update( # UPLOADED_PATH=os.path.join(BASEDIR, 'uploads'), # possibly unnecessary # Flask-Dropzone config: DROPZONE_ALLOWED_FILE_TYPE='image', DROPZONE_MAX_FILE_SIZE=5, DROPZONE_MAX_FILES=100, DROPZONE_UPLOAD_ON_CLICK=True, DROPZONE_REDIRECT_VIEW='collage', ) dropzone = Dropzone(app) @app.route('/', methods=['POST', 'GET']) def index(): """ 1. check if user exists, if not, add it to session object 2. create a temporary folder to store uploaded images 3. save all uploaded images 4. if new user, make folder for collages, if old user, folder already exists 5. make collage 6. save collage to user folder :return: rendered home page template """ # handle users regardless of the method user_id = handle_user() if request.method == 'GET': pass elif request.method == 'POST': # TODO: handle cases with different images with the same name # f is werkzeug.datastructures.FileStorage with tempfile.TemporaryDirectory() as tempdir: for key, f in request.files.items(): if key.startswith('file'): f.save(os.path.join(tempdir, f.filename)) print('RECEIVED AND SAVED AN IMAGE!') print("ALL IMAGES UPLOADED.") make_collage(user_id, tempdir) print("COLLAGE MADE!") return render_template('index.html', max_images=app.config['DROPZONE_MAX_FILES'], max_file_size=app.config['DROPZONE_MAX_FILE_SIZE']) @app.route('/collage') def collage(): """ Present all existing user's collages. Loop through existing files in user's directory and keep only .png Pass their paths to `collages.html` template. :return: rendered collages template """ if 'user' in session: user_path = USERS_DIR/session['user'] # only keep `.png` files sorted_file_paths = sort_from_new_to_old([str(f) for f in user_path.iterdir() if str(f).endswith('.png')]) # only keep path after 'static/`; it will be used with url_for('static') collages_paths = [str(f).split('static/')[1] for f in sorted_file_paths] return render_template('collages.html', collages=collages_paths) else: return "<h1>You don't have any collages yet.</h1>" @app.route('/user') def user(): """ Inform the user of their unique user id. :return: information about the user id """ if 'user' in session: return f"<h1>Your user id is: {session['user']}</h1>" else: return "This is a new user." return app