# -*- coding: utf-8 -*-
from flask import (Flask, request, render_template, session)
from flask_uploads import (UploadSet, configure_uploads, IMAGES, UploadNotAllowed)
from predict import (prediction_init, analysis, P_SUCCESS, P_NOTFOUND, P_UNDETECTED)
from cluster import get_cluster_images
import json
import os
import datetime
app = Flask(__name__)
uploaded_images = UploadSet('images', default_dest=lambda app: app.instance_path)
configure_uploads(app, uploaded_images)
def dump_response(cluster, sample_images, skin_color, hair_color, ratio,
contour, colors, clothes):
return json.dumps({'cluster': cluster,
'sample_images': sample_images,
'skin_color': skin_color,
'hair_color': hair_color,
'ratio': ratio,
'contour': contour,
'colors': colors,
'clothes': clothes})
@app.before_request
def make_session_permanent():
session.modified = True
@app.route('/')
from flask_wtf import FlaskForm
from flask_uploads import UploadSet, IMAGES
from wtforms import StringField, PasswordField, SubmitField, BooleanField, SelectField
from wtforms.validators import DataRequired, Length, Email, EqualTo, ValidationError
from webpage.models import User
from flask_wtf.file import FileField, FileAllowed, FileRequired
from werkzeug.utils import secure_filename
from werkzeug.datastructures import FileStorage
images = UploadSet('images', IMAGES)
state_addbrev = [('NA', 'None'), ('NA', 'Indian')]
class RegistrationForm(FlaskForm):
username = StringField('Username',
validators=[DataRequired(),
Length(min=2, max=20)])
email = StringField('Email', validators=[DataRequired(), Email()])
password = PasswordField('Password', validators=[DataRequired()])
confirm_password = PasswordField(
'Confirm Password', validators=[DataRequired(),
EqualTo('password')])
submit = SubmitField('Sign Up')
def validate_username(self, username):
user = User.query.filter_by(username=username.data).first()
if user:
raise ValidationError(
'That username is taken. Please choose a different one.')
def validate_email(self, email):
from flask_uploads import UploadSet, configure_uploads
from common import config
from src.definitions import INPUT_APK_DIR
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = config.MYSQL_URL
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
app.secret_key = os.urandom(24)
login_manager = LoginManager(app)
app.config['UPLOADED_APKS_DEST'] = INPUT_APK_DIR
apks = UploadSet('apks', ('apk',))
configure_uploads(app, (apks,))
app.config['CELERY_BROKER_URL'] = config.RABBITMQ_URL
app.config['CELERY_ROUTES'] = {
'static_analysis_task': {'queue': 'static_queue'},
'dynamic_analysis_task': {'queue': 'dynamic_queue'}}
app.config['CELERYD_PREFETCH_MULTIPLIER'] = 1
app.config['CELERY_ACKS_LATE'] = True
gevent.monkey.patch_all()
socketio = SocketIO(app, message_queue=config.RABBITMQ_URL)
def create():
con = db.connect()
cursor = con.cursor(db.getDictCursor())
cursor.execute("SELECT * FROM categories")
categories = cursor.fetchall()
cursor.execute("SELECT * FROM types")
types = cursor.fetchall()
form = ProductForm(request.form, csrf_enabled=False)
if request.method == 'POST' and form.validate_on_submit():
sku = request.form['sku'] or 'NULL'
name = request.form['name'] or 'NULL'
description = request.form['description'] or 'NULL'
category_id = request.form['category_id']
type_id = request.form['type_id']
normal_price = request.form['normal_price'] or 0
point = request.form['point'] or 0
weight = request.form['weight'] or 0
extra_fee = request.form['extra_fee'] or 0
created_by = session['user_id'] or 'NULL'
medias = request.files.getlist("medias[]")
is_disabled = 'is_disabled' in request.form
file_url = ""
sizes = ["S", "M", "L", "XL", "XXL"]
type = "image"
if is_disabled == True:
is_disabled = 1
else:
is_disabled = 0
photos = UploadSet('photos', IMAGES)
configure_uploads(app, photos)
con = db.connect()
cursor = con.cursor(db.getDictCursor())
try:
cursor.execute(
"INSERT INTO \
products( \
category_id, type_id, sku, name,\
description, normal_price, point, weight, extra_fee, \
is_disabled, created_by \
) VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)",
(category_id, type_id, sku, name, description, normal_price,
point, weight, extra_fee, is_disabled, created_by))
product_id = cursor.lastrowid
for size in sizes:
cursor.execute(
"INSERT INTO product_sizes(product_id, size) VALUES(%s, %s)",
(product_id, size))
for i, media in enumerate(medias):
sorting = str(request.form['sorting_' + str(i + 1)])
if allowed_file(media.filename):
filename = photos.save(media)
path = photos.url(filename)
cursor.execute(
"INSERT INTO product_media(product_id, path, sorting, type) VALUES(%s, %s, %s, %s)",
(product_id, path, sorting, type))
con.commit()
flash('Operation success')
return redirect(url_for('product.create'))
except cursor.InternalError as e:
code, message = e.args
con.rollback()
flash(message)
return redirect(url_for('product.create'))
finally:
con.close()
return render_template('back/product/create.html',
form=form,
categories=categories,
types=types)
import uuid
import smtplib
import psycopg2
import psycopg2.extras
from lib.config import *
from flask import Flask, render_template, session, request, redirect, url_for, current_app
from flask_uploads import UploadSet, configure_uploads
from werkzeug.utils import secure_filename
import flask_login
#from pdfjinja import PdfJinja
UPLOAD_FOLDER = "/home/danieladamsumw/CSVFiles"
ALLOWED_EXTENSIONS = set(['csv'])
UPLOADS_DEFAULT_DEST = "/home/danieladamsumw/CSVFiles"
files = UploadSet('files', ("csv"))
#pdfjinja = PdfJinja('form.pdf', current_app.jinja_env)
app = Flask(__name__)
app.secret_key = os.urandom(24).encode('hex')
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['UPLOADS_DEFAULT_DEST'] = UPLOADS_DEFAULT_DEST
configure_uploads(app, files)
from lib.config import *
from lib import postgresql_data as pg
#Global variables passed by the server to html pages
logged = ''
mail=Mail()
moment = Moment()
rd = FlaskRedis()
babel = Babel()
cache = Cache(config={
'CACHE_TYPE': 'redis',
'CACHE_REDIS_HOST': '127.0.0.1',
'CACHE_REDIS_PORT': 6379,
'CACHE_REDIS_DB': 2
})
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
videos = UploadSet('videos', ('mp4', 'flv', 'avi', 'wmv', 'mov', 'webm', 'mpeg4', 'ts', 'mpg', 'rm', 'rmvb', 'mkv'))
images = UploadSet('images', IMAGES)
def create_app(configname):
app = Flask(__name__)
app.config.from_object(config[configname])
db.init_app(app)
login_manager.init_app(app)
mail.init_app(app)
moment.init_app(app)
rd.init_app(app)
from app.admin_blueprint import f_admin
f_admin.init_app(app)
babel.init_app(app)
cache.init_app(app)
from redis import Redis
import rq
# class MySQLAlchemy(SQLAlchemy):
# def create_session(self, options):
# options['autoflush'] = False
# return SignallingSession(self, **options)
app = Flask(__name__)
app.config.from_object(Config)
login = LoginManager(app)
db = SQLAlchemy(app)
migrate = Migrate(app=app, db=db)
bootstrap = Bootstrap(app)
login.login_view = 'login'
text = UploadSet("downloads", TEXT)
configure_uploads(app, text)
moment = Moment(app)
babel = Babel(app)
redis = Redis.from_url(app.config['REDIS_URL'])
app.task_queue = rq.Queue('lightreader-tasks', connection=redis)
from app import models, routes
import create_db
@babel.localeselector
def get_locale():
return request.accept_languages.best_match(app.config['LANGUAGES'])
from redis import Redis
import rq
from config import Config
import flask_excel as excel
from flask_uploads import UploadSet, IMAGES, configure_uploads
db = SQLAlchemy()
migrate = Migrate()
login = LoginManager()
login.login_view = 'auth.login'
login.login_message = _l('Please log in to access this page.')
mail = Mail()
bootstrap = Bootstrap()
moment = Moment()
babel = Babel()
documents = UploadSet('documents')
def create_app(config_class=Config):
app = Flask(__name__)
app.config.from_object(config_class)
db.init_app(app)
migrate.init_app(app, db)
login.init_app(app)
mail.init_app(app)
bootstrap.init_app(app)
moment.init_app(app)
babel.init_app(app)
excel.init_excel(app)
configure_uploads(app, documents)
import os
import re
from werkzeug.datastructures import FileStorage
from typing import Union
from flask_uploads import UploadSet, IMAGES
IMAGE_SET = UploadSet("images", IMAGES) # set name and allowed extentions
def save_image(image: FileStorage,
folder: str = None,
name: str = None) -> str:
"""Takes FileStorage and saves it to a folder"""
return IMAGE_SET.save(image, folder, name)
def get_path(filename: str = None, folder: str = None) -> str:
return IMAGE_SET.path(filename, folder)
def find_image_any_format(filename: str, folder: str) -> Union[str, None]:
for _format in IMAGES:
image = f"{filename}.{_format}"
image_path = IMAGE_SET.path(filename=image, folder=folder)
if os.path.isfile(image_path):
return image_path
return None
def _retrieve_filename(file: Union[str, FileStorage]) -> str:
from flask import Flask, render_template, request
from flask_uploads import UploadSet, configure_uploads, IMAGES, UploadNotAllowed, TEXT
app = Flask(__name__)
photos = UploadSet('photos', IMAGES + TEXT + ('py', 'pyc', 'cpp'))
docs = UploadSet('docs', TEXT)
app.config['UPLOADED_PHOTOS_DEST'] = 'pictures'
app.config['UPLOADED_PHOTOS_ALLOW'] = ['txt', 'py']
# app.config['UPLOADED_PHOTOS_DENY'] = ['png']
app.config['UPLOADS_DEFAULT_DEST'] = 'other'
configure_uploads(app, (photos, docs))
@app.route('/upload', methods=['GET', 'POST'])
def upload():
if request.method == 'POST' and 'thefile' in request.files:
try:
doc_filename = docs.save(request.files['thefile'])
return '<h1>' + docs.url(doc_filename) + '</h1>'
except UploadNotAllowed:
return '<h1> File is not allowed </h1>'
else:
return render_template('upload.html')
if __name__ == '__main__':
app.run(debug=True)
from flask import Flask
from flask_bootstrap import Bootstrap
from flask_mail import Mail
from flask_moment import Moment
from flask_sqlalchemy import SQLAlchemy
from config import config
from flask_login import LoginManager
from flask_uploads import UploadSet, IMAGES, configure_uploads, patch_request_class, ALL
from flask_pagedown import PageDown
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
login_manager = LoginManager()
avatar = UploadSet('avatar', IMAGES)
files = UploadSet('files', ALL)
pictures = UploadSet('pictures', IMAGES)
page_down = PageDown()
login_manager.login_view = 'auth.login'
def create_app(config_name):
app = Flask(__name__)
# config[config_name] : config.py文件中定义的字典config
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
logger = logging.getLogger('sqlalchemy.engine')
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler())
if app.config.get('DATABASE_LOG_QUERIES', False):
configure_db_logger()
signals = Namespace()
calculation_finished = signals.signal('calculation-finished')
db = SQLAlchemy(app)
migrate = Migrate(app, db)
ma = Marshmallow(app)
resultfiles = UploadSet('results', extensions=ALL_EXTENSIONS)
configure_uploads(app, (resultfiles,))
# initialize Flask-Caching
cache = Cache(app)
# initialize Celery
def setup_celery():
# we need pickle support to serialize exceptions from
# tasks, otherwise we would need a catch-all handler in them.
app.config['CELERY_ACCEPT_CONTENT'] = ['pickle', 'json']
capp = Celery(app.import_name,
backend=app.config['CELERY_BACKEND'],
broker=app.config['CELERY_BROKER_URL'])
# from flask_markdown import Markdown
import os
import os.path as op
from flask_admin.contrib import fileadmin
from admin.views import CustomView
bootstrap = Bootstrap()
mail = Mail()
moment = Moment()
db = SQLAlchemy()
pagedown = PageDown()
# flask_admin = Admin()
photos = UploadSet('photos', ALL) # 创建set
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
def create_app(config_name):
app = Flask(__name__)
app.config.from_object(config[config_name])
config[config_name].init_app(app)
bootstrap.init_app(app)
mail.init_app(app)
moment.init_app(app)
db.init_app(app)
from flask import jsonify, request, abort
from flask_restful import Resource
from flask_uploads import UploadSet
from .celery_proj.tasks import transfer_data
from .schemes.upload_scheme import CsvFileUploadSchema
from .services.services_senders import SessionService
csv_uploader = UploadSet('CsvUploader')
CHUNK_SIZE = 50
class UploadCsv(Resource):
sessions_service = SessionService()
def post(self):
filename, project_id, session_id = self._validate_request(request)
# self._validate_session(session_id)
transfer_data.delay(project_id, CHUNK_SIZE, filename, "parser1")
return jsonify(dict(result='success'))
def _validate_session(self, session_id):
response = self.sessions_service.get(session_id)
if response.status_code != 200:
abort(300, {"message": "unauthorized access"})
@staticmethod
def _validate_request(request_):
schema = CsvFileUploadSchema().load(request_)
if schema.errors:
abort(400, {'message': schema.errors["file"]})
import os
from flask import Flask, render_template, request
from flask_uploads import DOCUMENTS, IMAGES, UploadSet, configure_uploads
app = Flask(__name__)
files = UploadSet('files')
# 上传的配置
app.config['UPLOADED_FILES_DEST'] = os.path.join(os.path.dirname(
os.path.abspath(__file__)), "data") # 配置文件保存的目录，本参数必须设置；
app.config['UPLOADED_FILES_ALLOW'] = [
DOCUMENTS, IMAGES, 'sav'] # 配置允许的扩展名，其他的都是不允许
app.config['UPLOADED_FILES_DENY'] = ['html'] # 配置不允许的扩展名
configure_uploads(app, files)
@app.route('/', methods=['GET'])
def hello_world():
return render_template('main.html')
@app.route('/upload', methods=['GET', 'POST'])
def upload():
if request.method == 'POST':
try:
# 将文件保存到指定位置
files.save(request.files['file'])
return render_template('main.html', info='上传成功')
except Exception:
return render_template('main.html', info='上传失败,不支持该类型文件')
from flask import Flask
from flask_uploads import UploadSet, ALL, configure_uploads
from settings import *
from datetime import timedelta
app = Flask(__name__)
# configure debug
# app.debug = DEBUG
# configure upload set
app.config['UPLOADED_PACKAGE_DEST'] = UPLOAD_FOLDER
app.config['SEND_FILE_MAX_AGE_DEFAULT'] = timedelta(seconds=1)
packages = UploadSet('PACKAGE', extensions="gaz")
configure_uploads(app, packages)
# import router view
from router import *
if __name__ == '__main__':
app.run(port=5001, threaded=True, debug=True, host=('0.0.0.0'))
# app.config.from_object(Config)
# app.upload_set_config()
file_url = "/home/CitizenScience/file"
file_dir = "image"
real_file_url = os.path.join(file_url, file_dir)
from flask import Blueprint, request
from flask_uploads import UploadSet, IMAGES, ARCHIVES
from io import BytesIO
import datetime
import random
profile = UploadSet("profile", IMAGES)
photo = UploadSet("photo", IMAGES)
feedback = UploadSet("feedback", IMAGES)
proofphoto = UploadSet("proofphoto", IMAGES)
dataimage = UploadSet("dataimage", IMAGES)
datazip = UploadSet("datazip", ARCHIVES)
'''
filename 是不带文件后缀的名字
path 是文件完整路径（包括文件名）
'''
def compress_image(filename, path):
new_filename = filename+"_cmprs.jpg"
from flask import Blueprint, render_template, request, redirect, url_for, flash, current_app
from flask_babel import gettext
from flask_security import login_required, current_user
from flask_uploads import UploadSet
import os
from forms import AccessoryAddForm, AccessoryEditForm
from models import db, Accessory
from utils import IMAGES, get_hashed_filename
bp_accessories = Blueprint("bp_accessories", __name__)
pictures = UploadSet("pictures", IMAGES)
@bp_accessories.route("/gear/accessory/add", methods=["GET", "POST"])
@login_required
def new():
pcfg = {"title": gettext("Add Accessory")}
form = AccessoryAddForm()
if form.validate_on_submit():
accessory = Accessory()
accessory.state = form.state.data
accessory.state_notes = form.state_notes.data
accessory.manufacturer = form.manufacturer.data
accessory.model = form.model.data
accessory.model_notes = form.model_notes.data
accessory.description = form.description.data
accessory.serial = form.serial.data
accessory.mount = form.mount.data
from flask import Flask
from flask_bootstrap import Bootstrap
from config import config_options
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager
from flask_uploads import UploadSet, configure_uploads, AUDIO
# Instances of flask extensions
login_manager = LoginManager()
login_manager.session_protection = 'strong'
login_manager.login_view = 'auth.login'
bootstrap = Bootstrap()
db = SQLAlchemy()
audios = UploadSet('audios', AUDIO)
def create_app(config_name):
'''
Function that takes configuration setting key as an argument
Args:
config_name : name of the configuration to be used
'''
# Initialising application
app = Flask(__name__)
# Creating the app configurations
app.config.from_object(config_options[config_name])
# Configure UploadSet
def map_key():
sc = SC()
return json.dumps(sc.map_key)
@app.errorhandler(404)
def page_not_found(error):
return render_template('index.html')
############################# Upload Setup ############################
app.config['UPLOADED_XMLFILES_DEST'] = get_tmp_dir()
app.config['UPLOADED_IMAGEFILES_DEST'] = os.path.join(sc_dir(), STATIC_DIR)
app.config['EARTHQUAKES'] = get_data_dir()
app.config['MESSAGES'] = {}
xml_files = UploadSet('xmlfiles', ('xml', ))
image_files = UploadSet('imagefiles',
IMAGES,
default_dest=app.config['UPLOADED_IMAGEFILES_DEST'])
configure_uploads(app, (xml_files, image_files))
ui = UI()
def get_file_type(file_name):
ext = file_name.split('.')[-1]
if ext in ['jpg', 'jpeg', 'png', 'bmp']:
return 'image'
elif ext in ['xml']:
return 'xml'
def update(id):
data = get_data(id)
sizes = []
con = db.connect()
cursor = con.cursor(db.getDictCursor())
cursor.execute("SELECT * FROM categories")
categories = cursor.fetchall()
cursor.execute("SELECT * FROM types")
types = cursor.fetchall()
cursor.execute("SELECT * FROM product_sizes WHERE product_id=%s", (id))
product_sizes = cursor.fetchall()
for ps in product_sizes:
sizes.append(ps['size'])
cursor.execute("SELECT * FROM product_media WHERE product_id=%s", (id))
product_media = cursor.fetchall()
form = ProductForm(obj=data, csrf_enabled=False)
if request.method == 'POST' and form.validate_on_submit():
sku = request.form['sku'] or 'NULL'
name = request.form['name'] or 'NULL'
description = request.form['description'] or 'NULL'
category_id = request.form['category_id']
type_id = request.form['type_id']
normal_price = request.form['normal_price'] or 0
point = request.form['point'] or 0
weight = request.form['weight'] or 0
extra_fee = request.form['extra_fee'] or 0
updated_by = session['user_id'] or 'NULL'
medias = request.files.getlist("medias[]")
post_sizes = request.form.getlist("sizes[]")
is_disabled = 'is_disabled' in request.form
file_url = ""
type = "image"
if is_disabled == True:
is_disabled = 1
else:
is_disabled = 0
photos = UploadSet('photos', IMAGES)
configure_uploads(app, photos)
con = db.connect()
cursor = con.cursor(db.getDictCursor())
try:
cursor.execute(
"UPDATE \
products SET category_id=%s, type_id=%s, sku=%s, \
name=%s, description=%s, normal_price=%s, point=%s, \
weight=%s, extra_fee=%s, is_disabled=%s, updated_by=%s \
WHERE id=%s",
(category_id, type_id, sku, name, description, normal_price,
point, weight, extra_fee, is_disabled, updated_by, id))
cursor.execute("DELETE FROM product_sizes WHERE product_id=%s",
(id))
for ps in post_sizes:
cursor.execute(
"INSERT INTO product_sizes(product_id, size) VALUES(%s, %s)",
(id, ps))
for i, media in enumerate(medias):
sorting = str(request.form['sorting_' + str(i + 1)])
media_id = str(request.form['id_' + str(i + 1)])
if allowed_file(media.filename):
filename = photos.save(media)
path = photos.url(filename)
if media_id == "":
cursor.execute(
"INSERT INTO product_media(product_id, path, sorting, type) VALUES(%s, %s, %s, %s)",
(id, path, sorting, type))
else:
cursor.execute(
"UPDATE product_media SET path=%s WHERE id=%s",
(path, media_id))
con.commit()
flash('Operation success')
return redirect(url_for('product.update', id=id))
except cursor.InternalError as e:
code, message = e.args
con.rollback()
flash(message)
return redirect(url_for('product.update', id=id))
finally:
con.close()
return render_template('back/product/update.html',
form=form,
data=data,
categories=categories,
sizes=sizes,
types=types,
product_sizes=product_sizes,
product_media=product_media)
from werkzeug.security import generate_password_hash
import os
import logging
from logging.handlers import SMTPHandler
app = Flask(__name__)
#app = Flask("Main")
app.config.from_object(Config)
bootstrap = Bootstrap(app)
db = SQLAlchemy(app)
excel.init_excel(app)
login = LoginManager(app)
login.login_view = 'login'
# Configure the image uploading via Flask-Uploads
excel_format = UploadSet('files', extensions=('xls', 'xlsx', 'csv'))
configure_uploads(app, excel_format)
if app.config['VANTAGE_UPLOAD_FOLDER']:
folders = [
a for a in app.config['VANTAGE_UPLOAD_FOLDER'].split("/")
if (a != "" and a != ".")
]
for i, folder in enumerate(folders):
folder = "/".join(folders[:i + 1]) # WE Want the current one as well.
if os.path.isdir(folder) == False:
os.mkdir(folder)
from app import routes, errors
if not app.debug:
import numpy as np
from sklearn import model_selection
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer
app = Flask(__name__)
files = UploadSet('files', ALL)
app.config['UPLOADED_FILES_DEST'] = 'upload'
configure_uploads(app, files)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///upload/filestorage.db'
db = SQLAlchemy(app)
@app.route('/')
def index():
return render_template('index.html')
@app.route('/upload', methods=['GET', 'POST'])
def datauploads():
if request.method == 'POST' and 'video' in request.files:
from flask import Blueprint
from flask_uploads import UploadSet, ARCHIVES, configure_uploads
quiz_archive = UploadSet('quizzes', extensions=('zip'))
video_file = UploadSet('videos', extensions=('mp4', 'webm'))
lecture_file = UploadSet('lectures', extensions=('pdf', 'pptx', 'ppt'))
root = ''
repo = Blueprint('repo', __name__, url_prefix='/repo')
from . import views
def configure_up(app):
configure_uploads(app, (quiz_archive, video_file, lecture_file))
root = app.instance_path
print(app.instance_path)
from wtforms.validators import InputRequired, Required
from flask_uploads import configure_uploads, UploadSet, patch_request_class
import os
import score
curr_path = os.path.abspath(os.path.dirname(__file__))
if not os.path.exists(os.path.join(curr_path, 'temp/')):
os.makedirs(os.path.join(curr_path, 'temp/'))
app = Flask(__name__)
app.secret_key = 'development key'
app.config['UPLOADED_RESUME_DEST'] = os.path.join(curr_path, 'temp/')
DOCUMENTS = ('txt', 'pdf', 'docx', 'doc')
resumes = UploadSet('resume', DOCUMENTS)
configure_uploads(app, resumes)
patch_request_class(app)
class MyForm(FlaskForm):
resume = FileField('resume',
validators=[
FileAllowed(
resumes,
"Only PDF, TXT, DOC, DOCX Files Allowed"),
Required("Resume is Required")
])
description = TextAreaField(
'description',
validators=[InputRequired("Job Description is required")])
from flask import Flask, render_template, url_for
from flask_wtf import FlaskForm
from wtforms import FileField
from flask_uploads import configure_uploads, IMAGES, UploadSet
import os
import numpy as np
import cv2
# CODE FOR APP
app = Flask(__name__, static_folder="/home/pi/Desktop/obj-detect-web/static")
app.config['SECRET_KEY'] = "clishmaclaver"
app.config['UPLOADED_IMAGES_DEST'] = "static"
images = UploadSet("images", IMAGES)
configure_uploads(app, images)
class ObjDetectForm(FlaskForm):
image = FileField("image")
@app.route("/", methods=["GET", "POST"])
def home():
form = ObjDetectForm()
if form.validate_on_submit():
filename = images.save(form.image.data)
detected = obj_detect("/home/pi/Desktop/obj-detect-web/static/" +
filename)
filename = "result_" + filename
cv2.imwrite("/home/pi/Desktop/obj-detect-web/static/" + filename,
from functools import wraps
from credentials import login_creds
ALLOWED_EXTENSIONS = set(['jpg', 'jpeg', 'heic'])
app = Flask(__name__)
app.secret_key = 'my_secret_key'
# basedir = pathlib.Path.cwd()
# alt base directory to try
basedir = pathlib.Path(__file__).parent.resolve()
photos = UploadSet('photos', IMAGES)
app.config['UPLOADED_PHOTOS_DEST'] = basedir / 'static' / 'long_term_storage' / 'uploads'
configure_uploads(app, photos)
def cookie_required(f):
@wraps(f)
def decorated_function(*args, **kwargs):
if 'family' not in request.cookies:
return redirect(url_for('home'))
return f(*args, **kwargs)
return decorated_function
@app.route('/')
def home():
if 'family' in request.cookies:
return redirect(url_for('activity_picker'))
Bootstrap(app)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'data.sqlite')
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
# lokacija slika
app.config['UPLOADS_DEFAULT_DEST'] = os.path.join(basedir, 'static/images')
return app
app = create_app()
slike = UploadSet('pizzas', IMAGES)
configure_uploads(app, slike)
patch_request_class(app)
db = SQLAlchemy(app)
# default slika
placeholderSrc = '../static/images/pizzas/placeholder.png'
class LoginForm(FlaskForm):
username = StringField(
'Username',
validators=[
DataRequired(),
Email(message="Username has to be in the form of email")
abort,
)
from flask_uploads import UploadSet, configure_uploads, IMAGES, patch_request_class
import datetime
import base64
from io import StringIO
from flask import current_app
import swagger_server.config as config
basedir = os.path.abspath(os.path.dirname(__file__))
ALLOWED_EXTENSIONS = set(["jpeg", "png", "gif"])
bp = Blueprint("img_bp", __name__, url_prefix="/")
uploaded_photos = UploadSet("photos")
def save_file(f):
file_dir = os.path.join(basedir, current_app.config["UPLOAD_FOLDER"])
content = StringIO(f.read())
try:
mime = Image.open(content).format.lower()
if mime not in ALLOWED_EXTENSIONS:
raise IOError()
else:
new_filename = str(uuid.uuid4()) + "." + mime
f.save(os.path.join(file_dir, new_filename))
except IOError:
print("error")
from flask import Flask, render_template
from flask_wtf import FlaskForm
from wtforms import FileField
from flask_uploads import patch_request_class, configure_uploads, UploadSet, IMAGES, DATA, TEXT, ARCHIVES
## pip install Flask-Reuploaded
app = Flask(__name__)
app.config['SECRET_KEY'] = 'thisisasecret'
patch_request_class(app, 25 * 1024 * 1024) # (n * 1024 * 1024) bytes
app.config['UPLOADED_UPLOADS_DEST'] = 'uploads/'
uploads = UploadSet('uploads', IMAGES + DATA + TEXT + ARCHIVES)
configure_uploads(app, uploads)
class MyForm(FlaskForm):
image = FileField('image')
@app.route('/', methods=['GET', 'POST'])
def index():
form = MyForm()
if form.validate_on_submit():
filename = uploads.save(form.image.data)
return '<h1>' + uploads.url(filename) + '</h1>'
return render_template('index.html', form=form)
if __name__ == '__main__':
