We Keep Coding

if request.method == 'POST' and 'sub' in request.form: is not working in flask: if condition is not executing

I'm doing a CRUD operation using flask and sqlalchemy. there're two input fields.
Subject and 2) Description and an ADD button. User enters the values and Add it to the database (sqlite3). Fortunately that's working. Even deletion is working.
But updating a row is not working.
I'm attaching my Flask code.
#app.route('/update/<id>/', methods = ['GET','POST'])
def update(id):
subj = ''
descr = ''
print("outside the if condition")
if request.method == 'POST' and 'subb' and 'dess' in request.form:
print("inside the if condition")
subj = request.form.get('sub')
print(subj)
descr = request.form.get('desc')
entry = Crud(subject = subj, description = descr)
db.session.add(entry)
db.session.commit()
searchThisId = Crud.query.get(id)
return render_template("update.html",searchThisId = searchThisId)
HTML
{% extends 'base.html' %}
{% block title %} Update the details {% endblock %}
{% block contents %}
<div>
<form method = 'POST', action = '/'>
<input type = "text" name = "subb" value = {{ searchThisId.subject }}><br>
<input type = "text" name = "dess" value = {{ searchThisId.description }}><br>
<input type = "submit" value = "UPDATE">
</form>
</div>
{% endblock %}

I don't have Flask setup, but I think your problem is here:
if request.method == 'POST' and 'subb' and 'dess' in request.form:
This statement is saying "if request.method is POST, and 'subb' is true, and 'dess' is an element of request.form (which is a dictionary I believe -- so this last part is what is always returning false.)
request.form is a dictionary, and you want to check that both 'subb' and 'dess' are keys in that dictionary right?
This should work:
if request.method == 'POST' and all(elem in request.form.keys() for elem in ['subb','dess'):

I modified the code like this, and working fine.
#app.route('/update/<id>/', methods = ['POST','GET'])
def update(id):
searchThisId = Crud.query.get(id)
if request.method == 'POST':
searchThisId.subject = request.form['subb']
searchThisId.description = request.form['dess']
db.session.commit()
return redirect(url_for('Index'))
else:
return render_template("update.html",searchThisId = searchThisId)
HTML
<form method = 'POST', action = "/update/{{ searchThisId.id }}/">
<input type = "text" name = "subb" value = {{ searchThisId.subject }}><br>
<input type = "text" name = "dess" value = {{ searchThisId.description }}><br>
<input type = "submit" value = "UPDATE">
</form>
Thankyou #MattBlaha for the help.

How do we handle empty forms in Flask?

I've written an app that reads data from a csv file and displays the student id and course id and their marks. I am having difficulty in handling situations when no buttons are selected and no text written and submit is pressed or when something is written in text field and no buttons are selected and submit is pressed.
Flask should render error.html in both of the above situations but I am getting a bad request error.
Please see the below code
from flask import render_template
from flask import Flask, request
from matplotlib import pyplot as plt
def read_csv():# Function to read csv
student_dic = {}
courses = []
file = open("./data.csv")
count = 0
a = file.readlines()
for line in a:
r = line.split(",")
if r[1] not in courses:
courses.append(r[1].strip())
r[2] = r[2].rstrip()
if count == 0:
count = count + 1
continue
if (r[0]) in student_dic:
k = {}
k[(r[1].strip())] = int(r[2])
student_dic[(r[0])].update(k)
else:
student_dic[(r[0])] = {(r[1].strip()): int(r[2])}
return ([student_dic, courses])
def plot_hist(marks_list):# Function to plot
plt.hist(marks_list)
plt.savefig("./static/hist.png")
plt.close()
app = Flask(__name__)
#app.route("/", methods=['GET', 'POST'])
def index():
if request.method == "GET":
return render_template("index.html")
elif request.method == "POST":
option = request.form["ID"]
print("here",option)
dic, courses = read_csv()
if option == "student_id":
user_input = (request.form["id_value"])
if user_input == '':
return render_template("error.html")
else:
if user_input in dic:
student_id_dic = dic[user_input]
total_marks = sum(student_id_dic.values())
return render_template("student_details.html", course_id_data=student_id_dic,
student_id_data=user_input,
total_marks_data=total_marks)
else:
return render_template("error.html")
elif option == "course_id":
user_input_course = request.form["id_value"]
if user_input_course == '':
return render_template("error.html")
else:
if user_input_course in courses:
ct = 0
max_marks = -1
total = 0
mark_list = []
h = 0
for student_id in dic:
for key, value in dic[student_id].items():
if key == user_input_course:
mark_list.append(value)
ct = ct + 1
total = total + value
if value > max_marks:
max_marks = value
plot_hist(mark_list)
return render_template("course_details.html", average_marks=(total / ct), maximum_marks=max_marks,
img='./static/hist.png')
else:
return render_template("error.html")
return render_template("error.html")
return render_template("error.html")
if __name__ == "__main__":
app.run(host='0.0.0.0')
app.debug = True
Here is the index html file
<!DOCTYPE html>
<html lang="en">
<head>
<title>Enter Details</title>
</head>
<body>
<div class="main">
<h1>Enter the details</h1>
<form method="POST" action="/" id = "data-form">
<input type="radio" name="ID" value="student_id" />
<label>Student ID</label>
<input type="radio" name="ID" value="course_id" />
<label>Course ID</label>
<input type="text" name="id_value" />
<input type="submit" value="Submit" />
</form>
</div>
</body>
</html>
This is the error html
<!DOCTYPE html>
<html lang="en">
<head>
<title>Something Went Wrong</title>
</head>
<body>
<div class="main">
<h1>Wrong Inputs</h1>
<p> Something went wrong </p>
<br>
Go Back
</div>
</body>
</html>

This would probably be better handled using form validators, rather than adding logic in the route and custom error pages. If you don't want users to submit the form without certain information, just make it impossible to do (using validators). This will also be a better user experience, since they won't have to click "Go Back" on the error page.
You can use built-in validators, such as DataRequired, and you can also write custom validation functions.

Web application: Flask - html - wtforms: form with two submit buttons

I am new to programming. I am interested in developing a simple web app with two input values and two submit buttons. Numbers A and B are input by users and the product OR the sum will be shown depending on which button is pressed. When I use one button, the code works; however, I can't seem to figure out how to make both buttons work. I wrote the application in Flask and Python 3.8 and used wtforms.
Here are my codes:
view.html
<table>
{% for field in form %}
<tr>
<td>{{ field.name }}</td><td>{{ field }}</td>
<td>{{ field.label }}</td>
</tr>
{% endfor %}
</table>
<form method="post" action="">
<input type="submit" name="btn" value="Add">
</form>
<p>
<form method="post" action="">
<input type="submit" name="btn" value="Multiply">
</form></p>
<p>
{% if result != None %}
{{result}}
{% endif %}
</p>
Python code
views.py
#app.route("/comp", methods=['GET', 'POST'])
def comp():
form = InputForm(request.form)
if request.method == 'POST' and form.validate():
if request.form["btn"] == "Add":
result = add(form.A.data, form.B.data)
elif request.form["btn"] == "Multiply":
result = mul(form.A.data, form.B.data)
else: result = None
return render_template('view.html', form=form, result=result)
I defined mul() and add() functions in a separate file, as I plan to expand the application further in the future. Here is the function definition:
def mul(A,B):
return A*B
def add(A,B):
return A+B
My input.py file:
from wtforms import Form, FloatField, validators
class InputForm(Form):
A = FloatField(
label='A', default=0,
validators=[validators.InputRequired()])
B = FloatField(
label='B', default=0,
validators=[validators.InputRequired()])

One of your values is "ADD", but you test for "Add". So, the equality test fails
UPDATE:
Where are you defining add() and mul()? Perhaps instead use:
if request.form['btn'] == 'Add':
result = form.A.data + form.B.data
elif request.form['btn'] == 'Multiply':
result = form.A.data * form.B.data
UPDATE2:
Try this to diagnose:
if request.method == 'POST' and form.validate():
print(request.form["btn"])
print(form.A.data, form.B.data)
print(request.POST)

You have 3 different forms. A and B are not part of either form you are submitting.

OK so I troubleshot your code. First thing first this is the result:
Flask Code :
from flask import Flask, request, render_template, url_for, flash, redirect
from wtforms import SubmitField, Form, FloatField, validators
app = Flask(__name__)
app.config['SECRET_KEY'] = 'dev'
def mul(A,B):
return A*B
def add(A,B):
return A+B
# Form
class InputForm(Form):
A = FloatField(
label='A', default=0,
validators=[validators.InputRequired()])
B = FloatField(
label='B', default=0,
validators=[validators.InputRequired()])
#app.route('/comp', methods=['GET', 'POST'])
#app.route('/', methods=['GET', 'POST']) #this so that both url will work
def comp():
result = '' #already assign a variable, else will throw error
form = InputForm(request.form)
if request.method == 'POST': #First we check if method is post **POINT 2**
if form.validate(): #Then if form is validate
print('form ok') #Test if form is ok
if request.form['btn'] == 'Add':
result = add(form.A.data, form.B.data)
print(result)
elif request.form['btn'] == 'Multiply':
result = mul(form.A.data, form.B.data)
print(result)
flash(result) # **POINT 3**
return redirect('comp') # This will make your code run forever #**4**
else:
print('form no ok ') #check if form no ok
else:
print('request is get') # if you put the form.validate with the method condition, the form will return False as soons as you render the template
return render_template('view.html', form=form, result=result)
if __name__ == '__main__':
app.run(debug=True)
HTML file:
<form method="post" action="">
<table>
<!-- Generates form fields -->
<!-- POINT 1 -->
{% for field in form %}
<td>{{ field.name }}</td><td>{{ field }}</td>
<td>{{ field.label }}</td>
</tr>
{% endfor %}
<tr>
<!-- Input are inside the form tag -->
<td><input type="submit" name="btn" value="Add"></td>
<td><input type="submit" name="btn" value="Multiply"></td>
</tr>
</table>
</form>
<!-- Print result in the browser -->
<!-- Needs to redirect to the same page -->
<!-- return redirect('comp') -->
{% for msg in get_flashed_messages()%}
<h1> {{msg}} </h1>
{% endfor%}
So the main issue was that in the HTML the form is not together with the input field, hence it was elaborating the form separately. By adding all together then it will start to work.
In the python file, the if request.method == 'POST' condition run simultaneously with the form hence returning the form False even before submit it.
.3 Added a Flash method so that you can see the result
.4 Add a redirect, this will flash the result to the browser, but most importantly will refresh the form and gives you possibility to add a new one.
Note that is also important to redirect the page because imagine if you want to commit it into a database, this will make you submit the form and save the changes.

If I understand the issue then try to do this:
from flask import render_template, redirect, url_for, flash, request
#app.route('/comp') #sample only
def comp():
form = InputForm(request.form)
if request.method == 'POST' and form.validate()
if request.form['btn'] == 'Add':
result = add(form.A.data, form.B.data)
elif request.form['btn'] == 'Multiply':
result = mul(form.A.data, form.B.data)
flash(result) # see the result in the browser
print('result') # see the result in the terminal
return redirect(url_for('comp'))
else:
result = None
return render_template('view.html', form=form, result=result)
to implement the flash in the html simple add this somewhere
{% for msg in get_flashed_messages()%}
<h1> {{msg}} </h1>
{% endfor %}
I always add a print statement and a flash for troubleshooting purposes in order to see where the issue is.

How to return a response in callback function with flask

here is a dll, that can compare face distance, and the compareFace.dll, I need use callback to receive it's value
now, I want use flask to wrapper it, then can visit by http and json
lib= c.CDLL('comparedFace.dll')
CALLBACKFUNC = c.CFUNCTYPE(None, c.c_int, c.c_char_p)
lib.startComparedFace.restype = c.c_int
lib.startComparedFace.argtypes = (c.c_char_p, c.c_char_p, CALLBACKFUNC)
#app.route('/compare', methods=['GET', 'POST'])
def test():
if request.method == 'POST':
request_json = request.get_json()
print(request_json)
number = request_json.get('number')
image01 = request_json.get('image01')
image02 = request_json.get('image02')
print(image01)
print(image02)
#c.CFUNCTYPE(None, c.c_int, c.c_char_p)
#copy_current_request_context
def callback(status, result_string):
result_json = json.loads(result_string)
distance = result_json['compareResult']
resp_data = {
"number": number,
"distance": distance,
}
print(resp_data)
response = Response(
response=json.dumps(resp_data),
status=200,
mimetype='application/json'
)
return response
lib.startComparedFace(b'd:/1.jpg', b'd:/2.jpg', callback)
run the code, and I receive a error ValueError: View function did not return a response
I know, I should write a return 'xxx' as response
But, I want wait the callback function, and return response in the callback function, so how should I modify my code, thank you.

Let's see a simple scenario:
User gives his/her username.
Our function calculates a value based on the username. Making this dummy call as time consuming call using time.sleep function.
User receives the value after the operation is being completed.
This can be achieved by using the following code.
app.py:
import time
from flask import Flask, request, render_template
app = Flask(__name__)
#app.route('/', methods=["GET", "POST"])
def index():
username = None
value = 0
if request.method == 'POST':
username = request.form.get("username", None)
def calculate_value_based_on_username(user_given_name):
time.sleep(10)
return len(user_given_name)
if username:
value = calculate_value_based_on_username(username)
return render_template('app.html', username=username, value=value)
return render_template('app.html')
if __name__ == '__main__':
app.run(debug=True)
app.html:
<html>
<head></head>
<body>
{% if username %}
Hello {{ username }}! Length of your username: {{ value }}
{% else %}
Hello guest!
{% endif %}
<form action="/" method="post">
Username: <input type="text" name="username">
<input type="submit" name="submit" value="Submit">
</form>
</body>
</html>
Output:

Flask WTForms - How to identify multiple submit buttons on the same form? [duplicate]

I have multiple form on the same page that send post request to same handler
in flask.
I am generating forms using wtforms.
what is the best way to identify which form is submitted ?
I am currently using action="?form=oneform". I think there should be some better method
to achieve the same?

The solution above have a validation bug, when one form cause a validation error, both forms display an error message. I change the order of if to solve this problem.
First, define your multiple SubmitField with different names, like this:
class Form1(Form):
name = StringField('name')
submit1 = SubmitField('submit')
class Form2(Form):
name = StringField('name')
submit2 = SubmitField('submit')
....
Then add a filter in view.py:
....
form1 = Form1()
form2 = Form2()
....
if form1.submit1.data and form1.validate(): # notice the order
....
if form2.submit2.data and form2.validate(): # notice the order
....
Now the problem was solved.
If you want to dive into it, then continue read.
Here is validate_on_submit():
def validate_on_submit(self):
"""
Checks if form has been submitted and if so runs validate. This is
a shortcut, equivalent to ``form.is_submitted() and form.validate()``
"""
return self.is_submitted() and self.validate()
And here is is_submitted():
def is_submitted():
"""Consider the form submitted if there is an active request and
the method is ``POST``, ``PUT``, ``PATCH``, or ``DELETE``.
"""
return _is_submitted() # bool(request) and request.method in SUBMIT_METHODS
When you call form.validate_on_submit(), it check if form is submitted by the HTTP method no matter which submit button was clicked. So the little trick above is just add a filter (to check if submit has data, i.e., form1.submit1.data).
Besides, we change the order of if, so when we click one submit, it only call validate() to this form, preventing the validation error for both form.
The story isn't over yet. Here is .data:
#property
def data(self):
return dict((name, f.data) for name, f in iteritems(self._fields))
It return a dict with field name(key) and field data(value), however, our two form submit button has same name submit(key)!
When we click the first submit button(in form1), the call from form1.submit1.data return a dict like this:
temp = {'submit': True}
There is no doubt when we call if form1.submit.data:, it return True.
When we click the second submit button(in form2), the call to .data in if form1.submit.data: add a key-value in dict first, then the call from if form2.submit.data: add another key-value, in the end, the dict will like this:
temp = {'submit': False, 'submit': True}
Now we call if form1.submit.data:, it return True, even if the submit button we clicked was in form2.
That's why we need to define this two SubmitField with different names. By the way, thanks for reading(to here)!
Update
There is another way to handle multiple forms on one page. You can use multiple views to handle forms. For example:
...
#app.route('/')
def index():
register_form = RegisterForm()
login_form = LoginForm()
return render_template('index.html', register_form=register_form, login_form=login_form)
#app.route('/register', methods=['POST'])
def register():
register_form = RegisterForm()
login_form = LoginForm()
if register_form.validate_on_submit():
... # handle the register form
# render the same template to pass the error message
# or pass `form.errors` with `flash()` or `session` then redirect to /
return render_template('index.html', register_form=register_form, login_form=login_form)
#app.route('/login', methods=['POST'])
def login():
register_form = RegisterForm()
login_form = LoginForm()
if login_form.validate_on_submit():
... # handle the login form
# render the same template to pass the error message
# or pass `form.errors` with `flash()` or `session` then redirect to /
return render_template('index.html', register_form=register_form, login_form=login_form)
In the template (index.html), you need to render both forms and set the action attribute to target view:
<h1>Register</h1>
<form action="{{ url_for('register') }}" method="post">
{{ register_form.username }}
{{ register_form.password }}
{{ register_form.email }}
</form>
<h1>Login</h1>
<form action="{{ url_for('login') }}" method="post">
{{ login_form.username }}
{{ login_form.password }}
</form>

I've been using a combination of two flask snippets. The first adds a prefix to a form and then you check for the prefix with validate_on_submit(). I use also Louis Roché's template to determine what buttons are pushed in a form.
To quote Dan Jacob:
Example:
form1 = FormA(prefix="form1")
form2 = FormB(prefix="form2")
form3 = FormC(prefix="form3")
Then, add a hidden field (or just check a submit field):
if form1.validate_on_submit() and form1.submit.data:
To quote Louis Roché's:
I have in my template :
<input type="submit" name="btn" value="Save">
<input type="submit" name="btn" value="Cancel">
And to figure out which button was passed server side I have in my views.py file:
if request.form['btn'] == 'Save':
something0
else:
something1

A simple way is to have different names for different submit fields. For an
example:
forms.py：
class Login(Form):
...
login = SubmitField('Login')
class Register(Form):
...
register = SubmitField('Register')
views.py:
#main.route('/')
def index():
login_form = Login()
register_form = Register()
if login_form.validate_on_submit() and login_form.login.data:
print "Login form is submitted"
elif register_form.validate_on_submit() and register_form.register.data:
print "Register form is submitted"
...

As the other answers, I also assign a unique name for each submit button, for each form on the page.
Then, the flask web action looks like below - note the formdata and obj parameters, which help to init / preserve the form fields accordingly:
#bp.route('/do-stuff', methods=['GET', 'POST'])
def do_stuff():
result = None
form_1 = None
form_2 = None
form_3 = None
if "submit_1" in request.form:
form_1 = Form1()
result = do_1(form_1)
elif "submit_2" in request.form:
form_2 = Form2()
result = do_2(form_2)
elif "submit_3" in request.form:
form_3 = Form3()
result = do_3(form_3)
if result is not None:
return result
# Pre-populate not submitted forms with default data.
# For the submitted form, leave the fields as they were.
if form_1 is None:
form_1 = Form1(formdata=None, obj=...)
if form_2 is None:
form_2 = Form2(formdata=None, obj=...)
if form_3 is None:
form_3 = Form3(formdata=None, obj=...)
return render_template("page.html", f1=form_1, f2=form_2, f3=form_3)
def do_1(form):
if form.validate_on_submit():
flash("Success 1")
return redirect(url_for(".do-stuff"))
def do_2(form):
if form.validate_on_submit():
flash("Success 2")
return redirect(url_for(".do-stuff"))
def do_3(form):
if form.validate_on_submit():
flash("Success 3")
return redirect(url_for(".do-stuff"))

I haven't used WTForms but should work regardless. This is a very quick and simple answer; all you need to do is use different values for the submit button. You can then just do a different def based on each.
In index.html:
<div>
<form action="{{ url_for('do_stuff')}}" method="POST">
<h1>Plus</h1>
<input type = "number" id = "add_num1" name = "add_num1" required><label>Number 1</label><br>
<input type = "number" id = "add_num2" name = "add_num2" required><label>Number 2</label><br>
<input type = "submit" value = "submit_add" name = "submit" ><br>
</form>
<p>Answer: {{ add }}</p>
</div>
<div>
<form action="{{ url_for('do_stuff')}}" method="POST">
<h1>Minus</h1>
<input type = "number" id = "min_num1" name = "min_num1" required><label>Number 1</label><br>
<input type = "number" id = "min_num2" name = "min_num2" required><label>Number 2</label><br>
<input type = "submit" value = "submit_min" name = "submit"><br>
</form>
<p>Answer: {{ minus }}</p>
</div>
in app.py:
#app.route('/',methods=["POST"])
def do_stuff():
if request.method == 'POST':
add = ""
minus = ""
if request.form['submit'] == 'submit_add':
num1 = request.form['add_num1']
num2 = request.form['add_num2']
add = int(num1) + int(num2)
if request.form['submit'] == 'submit_min':
num1 = request.form['min_num1']
num2 = request.form['min_num2']
minus = int(num1) - int(num2)
return render_template('index.html', add = add, minus = minus)

Well here is a simple trick
Assume you Have
Form1, Form2, and index
Form1 <form method="post" action="{{ url_for('index',formid=1) }}">
Form2 <form method="post" action="{{ url_for('index',formid=2) }}">
Now In index
#bp.route('/index', methods=['GET', 'POST'])
def index():
formid = request.args.get('formid', 1, type=int)
if formremote.validate_on_submit() and formid== 1:
return "Form One"
if form.validate_on_submit() and formid== 2:
return "Form Two"

I normally use a hidden tag that works as an identifier.
Here is an example:
class Form1(Form):
identifier = StringField()
name = StringField('name')
submit = SubmitField('submit')
class Form2(Form):
identifier = StringField()
name = StringField('name')
submit = SubmitField('submit')
Then you can add a filter in view.py:
....
form1 = Form1()
form2 = Form2()
....
if form1.identifier.data == 'FORM1' and form1.validate_on_submit():
....
if form2.identifier.data == 'FORM2' and form2.validate_on_submit():
....
and finally in the HTML:
<form method="POST">
{{ form1.indentifier(hidden=True, value='FORM1') }}
</form>
<form method="POST">
{{ form2.indentifier(hidden=True, value='FORM2') }}
</form>
If you do it like this in the if statement it will check what was the identifier and if its equal it will run the form stuff you have in your code.

Example: Multiple WTForm in single html page
app.py
"""
Purpose Create multiple form on single html page.
Here we are having tow forms first is Employee_Info and CompanyDetails
"""
from flask import Flask, render_template, request
from flask_wtf import FlaskForm
from wtforms import StringField, IntegerField, FloatField, validators
from wtforms.validators import InputRequired
app = Flask(__name__)
app.config['SECRET_KEY'] = 'Thisisasecret'
class EmployeeInfo(FlaskForm):
"""
EmployeeInfo class will have Name,Dept
"""
fullName = StringField('Full Name',[validators.InputRequired()])
dept = StringField('Department',[validators.InputRequired()])
class CompanyDetails(FlaskForm):
"""
CompanyDetails will have yearOfExp.
"""
yearsOfExp = IntegerField('Year of Experiece',[validators.InputRequired()])
#app.route('/', methods = ['GET','POST'] )
def index():
"""
View will render index.html page.
If form is validated then showData.html will load the employee or company data.
"""
companydetails = CompanyDetails()
employeeInfo = EmployeeInfo()
if companydetails.validate_on_submit():
return render_template('showData.html', form = companydetails)
if employeeInfo.validate_on_submit():
return render_template('showData.html', form1 = employeeInfo)
return render_template('index.html',form1 = employeeInfo, form = companydetails)
if __name__ == '__main__':
app.run(debug= True, port =8092)
templates/index.html
<html>
<head>
</head>
<body>
<h4> Company Details </h4>
<form method="POST" action="{{url_for('index')}}">
{{ form.csrf_token }}
{{ form.yearsOfExp.label }} {{ form.yearsOfExp }}
<input type="submit" value="Submit">
</form>
<hr>
<h4> Employee Form </h4>
<form method="POST" action="{{url_for('index')}}" >
{{ form1.csrf_token }}
{{ form1.fullName.label }} {{ form1.fullName }}
{{ form1.dept.label }} {{ form1.dept }}
<input type="submit" value="Submit">
</form>
</body>
</html>
showData.html
<html>
<head>
</head>
<body>
{% if form1 %}
<h2> Employee Details </h2>
{{ form1.fullName.data }}
{{ form1.dept.data }}
{% endif %}
{% if form %}
<h2> Company Details </h2>
{{ form.yearsOfExp.data }}
{% endif %}
</body>
</html>