def upload(request):
try:
uid=request.COOKIES['me_uid']
except KeyError:
return HttpResponseRedirect('http://www.me.uestc.edu.cn/stu/index.php/Login/')
auth= UserAuth(uid).is_auth()
if not auth:
return HttpResponseRedirect('http://www.me.uestc.edu.cn/stu/index.php/Login/')
if request.method == "POST":
form = UploadFileForm(request.POST,request.FILES)
typ=request.FILES['files'].name.split('.')[1]
if not (typ=='xls' or typ=='xlsx'):
return HttpResponse("<h1>上传失败 只能上传excel文件</h1></br><a href='upload'>返回重新上传</a>")
if form.is_valid():
files = open('static/excel.xls','w+')
for chunk in request.FILES['files'].chunks():
files.write(chunk)
files.close()
up_suc=handle_upload_file()
if up_suc :
q=u"上传失败，请以学号为第一列！"
else:
q=u"上传成功！"
return render_to_response('success.html',{'q':q})
else :
form = UploadFileForm()
return render_to_response('upload.html', {'form': form})
def uploadFile(request, course_id):
if request.method == 'POST':
c = Course.objects.get(pk=course_id)
upFile = UploadFileForm(request.POST, request.FILES)
data = upFile.data
if upFile.is_valid():
data = upFile.cleaned_data
newFile = Resource(name = data['name'], description = data['description'], type = 'File',
docfile = request.FILES['docfile'], sourceLink = '', course = c)
newFile.save()
return HttpResponseRedirect('/course/%d'%c.id)
else:
resources = Resource.objects.all()
context = RequestContext(request,
{
'c' : c,
'resources' : resources,
'upFileForm' : UploadFileForm(
initial={'name':data['name'], 'description':data['description']}
),
'upLinkForm' : UploadSourceLinkForm(),
'errorFile' : 'Please fill all information'
}
)
return render_to_response('course.html',context)
else:
return viewCourse(request,course_id)
def upload(user):
"""Upload a file from a client machine."""
file = UploadFileForm()
if file.validate_on_submit():
f = file.file_selector.data
filename = secure_filename(f.filename)
mrn = file.mrn.data
if filename[-4:] != '.wav':
flash('File type must be .wav')
elif len(mrn) != 7 or not mrn.isnumeric():
flash('MRN must be a 7 digit number')
else:
file_dir_path = os.path.join(application.instance_path, 'files')
file_path = os.path.join(file_dir_path, filename)
f.save(file_path)
# Add this to the queue table
current_id = User.query.filter_by(username=user).first().id
transcription_id = str(uuid.uuid4())
now_utc = pytz.utc.localize(datetime.utcnow())
now_pst = now_utc - timedelta(hours=7)
upload_row = Queue(id=current_id,
mrn=mrn,
transcription_id=transcription_id,
timestamp=now_pst,
filename=filename)
db.session.add(upload_row)
db.session.commit()
return redirect(url_for('queue', user=user))
return render_template('upload.html', form=file)
def upload_file():
form = UploadFileForm()
if form.validate_on_submit():
card = form.card.data
year = form.year.data
month = form.month.data
owner = form.owner.data
file = form.file.data
if not file or file.filename == '':
return make_response("no file, error! ")
if file and allowed_file(file.filename):
filename = "_".join([card, year, month, owner, 'Transactions.csv'])
path = os.path.join(app.config['BASE_FOLDER'], 'app', 'uploads',
filename)
try:
file.save(path)
parseAndSaveTransctions(card, owner, path)
except ValueError as ve:
return make_response(
"File parsing error, please check your uploading file type or card type: "
+ str(ve))
except Exception as e:
return make_response("Uploading filed failed, as: " + str(e))
return redirect(url_for('list_records'))
return render_template('home/uploadfile.html', form=form)
def upload(request):
try:
uid = request.COOKIES['me_uid']
except KeyError:
return HttpResponseRedirect(
'http://www.me.uestc.edu.cn/stu/index.php/Login/')
auth = UserAuth(uid).is_auth()
if not auth:
return HttpResponseRedirect(
'http://www.me.uestc.edu.cn/stu/index.php/Login/')
if request.method == "POST":
form = UploadFileForm(request.POST, request.FILES)
typ = request.FILES['files'].name.split('.')[1]
if not (typ == 'xls' or typ == 'xlsx'):
return HttpResponse(
"<h1>上传失败 只能上传excel文件</h1></br><a href='upload'>返回重新上传</a>")
if form.is_valid():
files = open('static/excel.xls', 'w+')
for chunk in request.FILES['files'].chunks():
files.write(chunk)
files.close()
up_suc = handle_upload_file()
if up_suc:
q = u"上传失败，请以学号为第一列！"
else:
q = u"上传成功！"
return render_to_response('success.html', {'q': q})
else:
form = UploadFileForm()
return render_to_response('upload.html', {'form': form})
def upload_file():
form = UploadFileForm()
if form.validate_on_submit():
app.logger.info('import file')
data = fJson.load(form.selected_file.data)
#app.logger.info(data[0]['tags'][0])
flash('Import success.')
return render_template('upload.html', form=form)
def upload_file(request):
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES) # 注意获取数据的方式
if form.is_valid():
handle_uploaded_file(request.FILES['file'])
return HttpResponseRedirect('/success/url/')
else:
form = UploadFileForm()
return render(request, 'upload.html', {'form': form})
def upload_file(request):
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
#print (form)
if form.is_valid():
print("Hai")
pred_data = handle_uploaded_file(request.FILES['file'])
return JsonResponse(pred_data, safe=False)
return JsonResponse(['Error'], safe=False)
def upload(request):
form = UploadFileForm()
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
p = Post()
p.description = request.POST['description']
p.image = request.FILES['file']
p.user = request.user
p.save()
return redirect('/')
return render(request, 'upload.html', {'form': form})
def show_model(request):
"""
Handle Request POST with uploded file
:param request: Request object.
:return:
"""
if request.method == 'POST':
upload_file_form = UploadFileForm(request.POST, request.FILES)
if upload_file_form.is_valid():
diagram_name_unique_id = handle_uploaded_file(
request.FILES['diagram_file'])
request.session['diagram_name'] = diagram_name_unique_id
return HttpResponseRedirect('/open_external_diagram')
else:
return HttpResponseRedirect('/')
def index(self, request):
pesan = ""
#assert isinstance(request, HttpRequest)
if request.method == "POST":
pesan = "simpan|false"
fileForm = UploadFileForm(request.POST, request.FILES)
if fileForm.is_valid():
imagesave = ModelTraining()
imagesave.datatraining = fileForm.cleaned_data['datatraining']
imagesave.save()
pesan = "simpan|true"
else:
file = ModelTraining()
return self.tampilHalaman(request, pesan)
def newSheetPage(request):
""" NewSheet view to show the UploadSheetForm """
# TODO: Create an option to upload a new version of a file
student = getStudent(request.user)
if request.method == "POST":
sheetForm = UploadSheetForm(student=student, data=request.POST)
fileForm = UploadFileForm(data=request.POST, files=request.FILES.getlist('file'))
if fileForm.is_valid() and sheetForm.is_valid():
files = request.FILES.getlist('file')
sheet = sheetForm.save(commit=False)
if splitext(files[0].name)[1] in ('.jpeg', '.jpg', '.png'):
sheet.thumbnail = files[0]
print('THUMBNAILED')
else:
sheet.thumbnail = None
sheet.uploadedBy = student
sheet.save()
for file in files:
uploadedFile = UploadedFile()
uploadedFile.file = file
uploadedFile.extension = splitext(file.name)[1]
uploadedFile.contentType = file.content_type
uploadedFile.relatedSheet = sheet
uploadedFile.save()
localVarsJSON = json.dumps({'success': 'true',})
messages.add_message(request, messages.SUCCESS, 'Votre fiche a bien été envoyée !')
return HttpResponse(localVarsJSON, content_type='application/json')
else:
errors = []
if not fileForm.is_valid(): errors.append(fileForm.errors)
if not sheetForm.is_valid(): errors.append(sheetForm.errors)
return HttpResponse(json.dumps(errors), content_type='application/json')
else:
raise Http404('Hey :/ I wasn\'t expecting you here !')
def upload_file():
# os.listdir('/Volumes') lists drives on MacOS
# desktop = os.path.join(os.path.join(os.environ['USERPROFILE']), 'Desktop') # This is the way to properly get to desktop
form = UploadFileForm()
if form.is_submitted():
# print(form.data)
if form.path.data == '':
name_tuple = save_file(file=form.uploaded_file.data)
file_obj = UploadedFile(path='/static/uploads/',
drive='app.root_path',
filename=name_tuple[0],
uuid_name=name_tuple[1])
db.session.add(file_obj)
db.session.commit()
flash('File has been uploaded successfully.', 'success')
return redirect(url_for('view_files'))
# file_object = UploadedFile(path=)
return render_template('file_uploads.html', form=form, active='upload')
def upload(request):
if request.user.is_superuser:
context_dict = {}
if request.method == 'POST' and request.FILES['file']:
try:
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
def choice_func(row):
if (str(row[0]).lower().startswith("inc")):
row[0] = "income"
else:
row[0] = "expense"
try:
info = Info.objects.get(name=str(row[1]),
date=str(row[3]))
if (info.amount == row[2]):
return None
else:
info.delete()
return (row)
except:
return row
request.FILES['file'].save_to_database(
model=Info,
initializer=choice_func,
mapdict=['ttype', 'name', 'amount', 'date'])
done = 1
update()
form = UploadFileForm()
context_dict["form"] = form
context_dict["success"] = "Succesfully Uploaded!!"
return render(request, 'app/upload.html', context_dict)
except Exception as e:
print(e)
form = UploadFileForm()
context_dict["form"] = form
context_dict["error"] = e
return render(request, 'app/upload.html', context_dict)
else:
form = UploadFileForm()
context_dict["form"] = form
context_dict["error"] = "No file uploaded"
return render(request, 'app/upload.html', context_dict)
else:
return HttpResponseRedirect("/app/login/")
def upload():
"""Upload a file from a client machine."""
file = UploadFileForm()
if file.validate_on_submit():
f = file.file_selector.data
filename = secure_filename(f.filename)
file_dir_path = os.path.join(application.instance_path, 'files')
file_path = os.path.join(file_dir_path, filename)
# Save file to file_path (instance/ + 'files' + filename)
f.save(file_path)
file_dir_path = os.path.join(application.instance_path, 'files')
file_path = os.path.join(file_dir_path, filename)
# Convert audio file to text (String)
r = sr.Recognizer()
harvard = sr.AudioFile(file_path)
with harvard as source:
audio = r.record(source)
talk_to_text = r.recognize_google(audio)
# pipe results from talk to text to nlp model
example_result = prepare_note(spacy_model, talk_to_text)
"""Display the model results."""
proper_title_keys = [k.title() for k in list(example_result.keys())]
session['example_result'] = example_result
session['proper_title_keys'] = proper_title_keys
# delete the file
if os.path.exists(file_path):
os.remove(file_path)
else:
print("The file does not exist.")
return redirect(url_for('results', filename=filename))
return render_template('upload.html', form=file)
def event_list(request):
#verify user id
try:
if request.user.venue is None:
return redirect('/login/?next=%s' % request.path)
except ObjectDoesNotExist:
return redirect('/login/?next=%s' % request.path)
events = Event.objects.filter(venue__id=request.user.venue.id).filter(
start__gte=timezone.now()).all()
uploadForm = UploadFileForm(initial={'venue': request.user.venue.id})
return render(request, 'app/admin/event_list.html', {
'events': events,
'year': datetime.now().year,
'uploadForm': uploadForm
})
def upload_events(request):
file = request.FILES['file']
fs = FileSystemStorage()
venue = request.POST.get('venue')
#save the file to disk for processing
filename = fs.save(venue + '/' + file.name, file)
#BASE_DIR = os.path.dirname(os.path.abspath(__file__))
media_folder = settings.MEDIA_ROOT
wb = load_workbook(media_folder + '/' + filename,
read_only=True) #open the file and the events worksheet
ws = wb['Events']
event_type_to_index = dict()
for i, j in enumerate(
Event.EVENT_TYPES
): #load event_type_to_index to get the numeric value of the Event Type
event_type_to_index.update({j[1]: i})
for row in ws.iter_rows(row_offset=1): #process the events
event = Event(title=row[0].value,
event_type=(event_type_to_index[row[1].value] + 1),
description=row[2].value,
confirmed=(1 if row[3].value == 'Y' else 0),
start=localize(row[4].value),
venue_id=venue,
created=timezone.now())
if row[5].value is not None and row[
7] is not None: #only save customer info for Tentative bookings - this may change
customer = Customer(name=row[5].value,
email=row[6].value,
phone=row[7].value)
customer.save()
event.customer = customer
#only add an event if it doesn't already exist
event_validate = Event.objects.filter(title=row[0].value).filter(
venue_id=venue).filter(start__date=row[4].value.date()).first()
if event_validate is None:
event.save()
events = Event.objects.filter(venue__id=venue).filter(
start__gte=timezone.now()).all()
uploadForm = UploadFileForm(initial={'venue': venue})
return render(request, 'app/admin/event_list.html', {
'events': events,
'year': datetime.now().year,
'uploadForm': uploadForm
})
def file_upload(request):
# print('-------------------------------')
# print(request)
# print(request.POST)
# print(request.FILES)
# print('-------------------------------')
if (request.method == 'POST'):
form = UploadFileForm(request.POST, request.FILES)
if (form.is_valid()):
form.save()
return redirect('file_upload')
else:
print('[INFO] UploadFileForm is invalid')
upload_file_form = UploadFileForm()
else:
upload_file_form = UploadFileForm()
uploaded_files = UploadFiles.objects.all()
context = {
'upload_file_form': upload_file_form,
'uploaded_files': uploaded_files,
}
return render(request, "app/file_upload.html", context)
def admin_problem_file(problem_id):
#if it is not an admin user or the user is not logged does not display this page
if not current_user.is_authenticated or not current_user.admin:
return render_template('404.html')
if not ProblemInformation.query.filter_by(code=problem_id).first():
return redirect(url_for('admin'))
form = UploadFileForm(prefix='form')
form1 = DeleteFileForm(prefix='form1')
form11 = SetDescriptionForm(prefix='form11')
form2 = SetTestCaseForm(prefix='form2')
form3 = DeleteTestCaseForm(prefix='form3')
if form.submit.data and form.validate_on_submit():
filename = os.path.join(app.config['PROBLEMS_DIR'], problem_id,
form.file_name.data)
form.file_sent.data.save(filename)
f = ProblemFile.query.filter_by(problem_code=problem_id,
file_name=form.file_name.data).first()
if f:
f.visible = form.visible.data
db.session.commit()
flash("File overwritten.")
else:
file = ProblemFile(problem_id, form.file_name.data,
form.visible.data)
db.session.add(file)
db.session.commit()
flash("File uploaded.")
elif form1.submit.data and form1.validate_on_submit():
file = ProblemFile.query.filter_by(id=form1.file_id.data,
problem_code=problem_id).first()
if file:
path = os.path.join(app.config['PROBLEMS_DIR'], problem_id,
file.file_name)
db.session.delete(file)
db.session.commit()
os.unlink(path)
flash('File deleted.')
else:
flash('File not found.')
elif form11.submit.data and form11.validate_on_submit():
if form11.remove.data:
p = ProblemInformation.query.filter_by(code=problem_id).first()
p.description_file = None
db.session.commit()
flash('Description file removed')
else:
exists = ProblemFile.query.filter_by(
problem_code=problem_id,
id=form11.description_file.data).first()
if not exists:
flash('Description file not in problem!')
else:
p = ProblemInformation.query.filter_by(code=problem_id).first()
p.description_file = form11.description_file.data
db.session.commit()
flash('Description file set.')
elif form2.submit.data and form2.validate_on_submit():
in_file = ProblemFile.query.filter_by(
problem_code=problem_id, id=form2.input_file.data).first()
res_file = ProblemFile.query.filter_by(problem_code=problem_id,
id=form2.res_file.data).first()
exists = ProblemTestCaseInformation.query.filter_by(
problem_code=problem_id, test_case=form2.test_case.data).first()
if not in_file:
flash('The input file is not in this problem.')
if not res_file:
flash('The response file is not in this problem.')
elif not exists:
n = ProblemTestCaseInformation(problem_id, form2.test_case.data,
form2.input_file.data,
form2.res_file.data,
form2.is_open.data)
db.session.add(n)
db.session.commit()
flash('Test case added.')
else:
exists.input_file = form2.input_file.data
exists.res_file = form2.res_file.data
exists.is_open_case = form2.is_open.data
db.session.commit()
flash('Test case was overwritten.')
elif form3.submit.data and form3.validate_on_submit():
exists = ProblemTestCaseInformation.query.filter_by(
problem_code=problem_id, test_case=form3.test_case.data).first()
if exists:
db.session.delete(exists)
db.session.commit()
flash('Test case removed.')
else:
flash('Test case was not removed because it does not exist.')
return render_template(
'admin_problem_file.html',
title='Manage problem - files',
form=form,
form1=form1,
form11=form11,
form2=form2,
form3=form3,
problem=ProblemInformation.query.filter_by(code=problem_id).first(),
files=ProblemFile.query.filter_by(problem_code=problem_id).all(),
testcases=ProblemTestCaseInformation.query.filter_by(
problem_code=problem_id).all())
def uploadRegistered(request):
"""Upload and save the zip"""
if request.user.is_authenticated():
user = request.user.username
else:
return HttpResponseRedirect('/')
if request.method == 'POST':
form = UploadFileForm(request.POST)
# Analyze the scratch project and save in our server files
fileName = handle_uploaded_file(request.FILES['zipFile'])
# Analize project and to save in database the metrics
d = analyzeProject(request, fileName)
fupdate = datetime.now()
# Get the short name
shortName = fileName.split('/')[-1]
# Get the dashboard of user
myDashboard = Dashboard.objects.get(user=user)
# Save the project
newProject = Project(name=shortName,
version=1,
score=0,
path=fileName,
fupdate=fupdate,
dashboard=myDashboard)
newProject.save()
# Save the metrics
dmaster = d["mastery"]
newMastery = Mastery(myproject=newProject,
abstraction=dmaster["Abstraction"],
paralel=dmaster["Parallelization"],
logic=dmaster["Logic"],
synchronization=dmaster["Synchronization"],
flowcontrol=dmaster["FlowControl"],
interactivity=dmaster["UserInteractivity"],
representation=dmaster["DataRepresentation"],
TotalPoints=dmaster["TotalPoints"])
newMastery.save()
newProject.score = dmaster[
"Total{% if forloop.counter0|divisibleby:1 %}<tr>{% endif %}Points"]
if newProject.score > 15:
newProject.level = "advanced"
elif newProject.score > 7:
newProject.level = "developing"
else:
newProject.level = "beginner"
newProject.save()
for charx, dmetrics in d["attribute"].items():
if charx != 'stage':
newAttribute = Attribute(myproject=newProject,
character=charx,
orientation=dmetrics["orientation"],
position=dmetrics["position"],
costume=dmetrics["costume"],
visibility=dmetrics["visibility"],
size=dmetrics["size"])
newAttribute.save()
iterator = 0
for deadx in d["dead"]:
if (iterator % 2) == 0:
newDead = Dead(myproject=newProject, character=deadx, blocks=0)
else:
newDead.blocks = deadx
newDead.save()
iterator += 1
newDuplicate = Duplicate(myproject=newProject,
numduplicates=d["duplicate"][0])
newDuplicate.save()
for charx in d["sprite"]:
newSprite = Sprite(myproject=newProject, character=charx)
newSprite.save()
return HttpResponseRedirect('/myprojects')
def upload_file(request):
data_name = 'Загрузка информации в БД'
if Group.objects.filter(name='Authors').count() == 0:
Group.objects.create(name='Admins')
Group.objects.create(name='Editors')
Group.objects.create(name='Authors')
Group.objects.create(name='Guests')
return redirect('articles')
else:
usergroup = get_usergroup(request)
if usergroup == 'Admins':
if request.method == 'POST':
form = UploadFileForm(request.POST, request.FILES)
if form.is_valid():
# так производится создание объектов модели FileModel и запись их в базу данных
p1 = FileModel.objects.create(file=request.FILES['file'])
data_way1 = 'app/static/'
data_way2 = str(request.FILES['file'])
data_way = data_way1 + data_way2
excel_data_file = xlrd.open_workbook(data_way)
sheet_3 = excel_data_file.sheet_by_index(3) #Users, Авторы
sheet_4 = excel_data_file.sheet_by_index(
4) #Usrrs, Редакторы
row_number = sheet_3.nrows # количество строк
if row_number > 0: # Проверка на пустоту файла
for row in range(1, row_number):
if User.objects.filter(
username=str(sheet_3.row(row)[0]).replace(
"text:", "").replace("'",
"")).count() == 0:
user = User.objects.create_user(
username=str(sheet_3.row(row)[0]).replace(
"text:", "").replace("'", ""),
email=str(sheet_3.row(row)[7]).replace(
"text:", "").replace("'", ""),
password=str(sheet_3.row(row)[0]).replace(
"text:", "").replace("'", ""))
group = Group.objects.get(name='Authors')
group.user_set.add(user)
permission = Permission.objects.get(
name='Can add Article')
user.user_permissions.add(permission)
permission = Permission.objects.get(
name='Can change Article')
user.user_permissions.add(permission)
permission = Permission.objects.get(
name='Can delete Article')
user.user_permissions.add(permission)
AuthorModel.objects.create(
login=user,
index="",
name=str(sheet_3.row(row)[1]).replace(
"text:", "").replace("'", ""),
birth_date=str(
sheet_3.row(row)[2]).replace(
"text:",
"").replace("'",
"").replace(".", ""),
degree=str(sheet_3.row(row)[3]).replace(
"text:", "").replace("'", ""),
title=str(sheet_3.row(row)[4]).replace(
"text:", "").replace("'", ""),
work=str(sheet_3.row(row)[5]).replace(
"text:", "").replace("'", ""),
position=str(sheet_3.row(row)[6]).replace(
"text:", "").replace("'", ""),
email=str(sheet_3.row(row)[7]).replace(
"text:", "").replace("'", ""),
education=str(sheet_3.row(row)[8]).replace(
"text:", "").replace("'", ""))
author = AuthorModel.objects.get(index="")
author.index = str(author.id)
author.save()
row_number = sheet_4.nrows # количество строк
if row_number > 0: # Проверка на пустоту файла
for row in range(1, row_number):
if User.objects.filter(
username=str(sheet_4.row(row)[0]).replace(
"text:", "").replace("'",
"")).count() == 0:
user = User.objects.create_user(
username=str(sheet_4.row(row)[0]).replace(
"text:", "").replace("'", ""),
email=str(sheet_4.row(row)[8]).replace(
"text:", "").replace("'", ""),
password=str(sheet_4.row(row)[0]).replace(
"text:", "").replace("'", ""))
group = Group.objects.get(name='Editors')
group.user_set.add(user)
editor = EditorModel.objects.create(
login=user,
name_magazine=str(
sheet_4.row(row)[3]).replace(
"text:", "").replace("'", ""),
name=str(sheet_4.row(row)[1]).replace(
"text:", "").replace("'", ""),
birth_date=str(
sheet_4.row(row)[2]).replace(
"text:",
"").replace("'",
"").replace(".", ""),
degree=str(sheet_4.row(row)[4]).replace(
"text:", "").replace("'", ""),
title=str(sheet_4.row(row)[5]).replace(
"text:", "").replace("'", ""),
work=str(sheet_4.row(row)[6]).replace(
"text:", "").replace("'", ""),
position=str(sheet_4.row(row)[7]).replace(
"text:", "").replace("'", ""),
email=str(sheet_4.row(row)[8]).replace(
"text:", "").replace("'", ""),
education=str(sheet_4.row(row)[9]).replace(
"text:", "").replace("'", ""))
p1.delete()
data_name = "Загрузка завершена"
return render_to_response('upload.html',
{'data_name': data_name})
else:
return render_to_response(
'upload.html', {
'form': form,
'data_name': "Ошибка ввода данных"
})
else:
form = UploadFileForm()
return render_to_response('upload.html', {
'form': form,
'data_name': data_name
})
else:
return redirect('articles')
def index():
global selected_dataset, last_dataset
# ^ it's bad decision...
if selected_dataset is None:
selected_dataset = request.args.get("dataset")
if selected_dataset is not None:
last_dataset = selected_dataset
return redirect(url_for(".index"))
header = None
if session.get("current_data") is not None:
header = get_header(session["current_data"])
simplegraph_form = SimpleGraphForm(header)
anomalies_form = AnomaliesForm(algorithms)
dataoverview_form = DataOverviewForm()
upload_form = UploadFileForm()
kwargs = dict(
upload_form=upload_form,
simplegraph_form=simplegraph_form,
anomalies_form=anomalies_form,
dataoverview_form=dataoverview_form,
header=header,
)
def _get_axes(axes_form):
"""
Return selected columns to draw plots with.
:return: (axis_x, axis_y)
"""
return (
dict(axes_form.axis_x.choices)[axes_form.axis_x.data],
dict(axes_form.axis_y.choices)[axes_form.axis_y.data],
)
def _get_algorithm():
return dict(anomalies_form.selected_algorithm.choices)[
anomalies_form.selected_algorithm.data]
def _filesize(path):
fs = os.path.getsize(path)
m = "B"
if fs > 1025:
fs /= 1024
m = "KB"
if fs > 1025:
fs /= 1024
m = "MB"
if fs > 1025:
fs /= 1024
m = "GB"
fs = round(fs)
res = "{} {}".format(str(fs), m)
return res
# Display content of dataset.
if upload_form.validate_on_submit() or selected_dataset is not None:
if selected_dataset is not None:
uploaded_file = os.path.join("uploads", selected_dataset)
else:
uploaded_file = upload_form.uploaded_file.data
session["current_data"] = get_json_data(uploaded_file)
header = get_header(session["current_data"])
values = get_values(session["current_data"])
simplegraph_form.change_choices(header)
if selected_dataset is not None:
session["current_file_id"] = save_uploaded_file(uploaded_file,
skip=True)
kwargs.update(dataset=selected_dataset)
selected_dataset = None
else:
session["current_file_id"] = save_uploaded_file(uploaded_file)
kwargs.update(dataset=upload_form.uploaded_file.data.filename)
last_dataset = kwargs["dataset"]
mat = db_queries.get_dataframe(session["current_file_id"])
y = mat["outlier"].values
X = mat.drop("outlier", axis=1).values
n_dim = X.shape[1] - 1
n_obj = len(y)
n_out = np.count_nonzero(y)
percentage = round(100 * n_out / n_obj, 2)
kwargs.update(
simplegraph_form=simplegraph_form,
anomalies_form=anomalies_form,
header=header,
data=values,
n_dim=n_dim,
n_obj=n_obj,
n_out=n_out,
percentage=percentage,
)
return render_template("showcsv.html", **kwargs)
# Simple plots.
if simplegraph_form.submit_graph.data:
try:
axis_x, axis_y = _get_axes(simplegraph_form)
except:
axis_x, axis_y = None, None
if "current_file_id" not in session:
uploaded_file = os.path.join("uploads", last_dataset)
session["current_file_id"] = save_uploaded_file(uploaded_file,
skip=True)
session["current_data"] = get_json_data(uploaded_file)
header = get_header(session["current_data"])
simplegraph_form.change_choices(header)
kwargs.update(simplegraph_form=simplegraph_form)
filename = plot_df.naive_plot_df(session["current_file_id"], axis_x,
axis_y)
kwargs.update(filename=filename,
axis_x=axis_x,
axis_y=axis_y,
dataset=last_dataset)
return render_template("showgraph.html", **kwargs)
# Anomaly Detection.
if anomalies_form.submit_anomalies.data:
# axis_x, axis_y = _get_axes(simplegraph_form)
selected_algortihm = _get_algorithm()
if "current_file_id" not in session:
uploaded_file = os.path.join("uploads", last_dataset)
session["current_file_id"] = save_uploaded_file(uploaded_file,
skip=True)
session["current_data"] = get_json_data(uploaded_file)
header = get_header(session["current_data"])
simplegraph_form.change_choices(header)
kwargs.update(simplegraph_form=simplegraph_form)
filename_analyze_selected_algorithm = plot_anomalies.analyze_selected_algorithm(
session["current_file_id"], last_dataset, selected_algortihm)
# filename_simple_plot = plot_anomalies.simple_plot(
# session["current_file_id"], axis_x, axis_y
# )
# filename_simple_anomalies = plot_anomalies.simple_anomalies(
# session["current_file_id"], axis_x, axis_y
# )
# filename_data_overview = plot_anomalies.data_overview(
# session["current_file_id"], dataset_title=last_dataset
# )
kwargs.update(
algorithms=algorithms,
# axis_x=axis_x,
# axis_y=axis_y,
# filename_simple_plot=filename_simple_plot,
# filename_simple_anomalies=filename_simple_anomalies,
# filename_data_overview=filename_data_overview,
filename_analyze_selected_algorithm=
filename_analyze_selected_algorithm,
dataset=last_dataset,
)
return render_template("showanomalies.html", **kwargs)
# Data Overview.
if dataoverview_form.validate_on_submit():
if "current_file_id" not in session:
uploaded_file = os.path.join("uploads", last_dataset)
session["current_file_id"] = save_uploaded_file(uploaded_file,
skip=True)
session["current_data"] = get_json_data(uploaded_file)
header = get_header(session["current_data"])
simplegraph_form.change_choices(header)
kwargs.update(simplegraph_form=simplegraph_form)
filename_data_overview = plot_anomalies.data_overview(
session["current_file_id"], dataset_title=last_dataset)
kwargs.update(filename_data_overview=filename_data_overview,
dataset=last_dataset)
return render_template("showdataoverview.html", **kwargs)
datasets = sorted(os.listdir("uploads/"), key=str.lower)
datasets = list(filter(lambda x: x.startswith(".") is False, datasets))
datasets = list(
map(lambda x: (x, _filesize(os.path.join("uploads", x))), datasets))
kwargs.update(datasets=datasets)
return render_template("showdatasets.html", **kwargs)
