We Keep Coding

Define a common route pass-through or filter for all Python Flask Blueprint Routes

In my Python Flask app I have Blueprint Routes defined that correspond to API endpoints,
# Submit Agreement (Insert or Update)
#bp.route('submitAgreement', methods=['POST'])
#auth.login_required
def submitAgreement():
#...code...
# Get Existing Agreement
#bp.route('fetchAgreement', methods=['POST'])
#auth.login_required
def fetchAgreement():
#...code...
I need to define a common route pass-through or filter that will perform authorization prior to executing the code. The authorization needs to be, if the URL contains the param id=.., check that that ID belongs to the logged-in user.
Is there a way to define a custom "aspect" or filter with this code in Python Flask?

Flask offers an
#app.before_request decorator
You can substitute app for bp to apply the function you define to just the blueprint.

What is the "endpoint" parameter for #app.route() used for?

In Flask, you create routes like this:
from flask import Flask
app = Flask(__name__)
#app.route("/foobar")
def foo_bar_endpoint():
...
But the route decorator also has an endpoint parameter. The documentation just states:
the endpoint for the registered URL rule. Flask itself assumes the name of the view function as endpoint
Why should / would one not simply name the function as the endpoint should be called? Is this relevant for anything else than url_for?

The "endpoint" is an arbitrary name you provide, which is basically the canonical thing that a route refers to. You're not actually mapping a URL to a function there, you're mapping a URL to an endpoint and are attaching a view function to that endpoint.
URL → endpoint → function
You're just doing all that in one action, and the name of the function automatically becomes the name of the endpoint in the process. But you could do this all separately and register an endpoint for a URL, and later attach a function to that endpoint:
Basically this example:
#app.route('/')
def index():
pass
Is equivalent to the following:
def index():
pass
app.add_url_rule('/', 'index', index)
If the view_func is not provided you will need to connect the endpoint to a view function like so:
app.view_functions['index'] = index
https://flask.palletsprojects.com/en/1.1.x/api/#flask.Flask.add_url_rule
You may want to name your endpoint independently of your function, if you're under some constraint for the function name but are already referring to the endpoint from elsewhere, especially during refactoring, as one possible example where that might become relevant.

The URL is for external clients, for HTTP-requests.
The endpoint is for internal usage if you need to know which URL to redirect for example without any hardcoding.
In case you not defining endpoint your code looks like:
blueprint = Blueprint("bp_1", __name__)
#blueprint.route("/foobar")
def foo_bar_endpoint():
...
url = flask.url_for("bp_1.foo_bar_endpoint")
In case you define endpoint, you use function url_for with its name:
#blueprint.route("/foobar", endpoint="custom_name")
def foo_bar_endpoint():
...
url = flask.url_for("bp_1. custom_name")

Using Flask API instead of render_template

last year i developed a big website using Flask.
I used render_template method to send data from back-end to front-end and request.form to get data from front-end to back-end
Now, my product owner wants me to use "API" instead of above solutions.
And i'm fully confused how to use API.
Should i remove any render_template or request.form?
Should i change my back-end and view functions completely?
Am i able to just change render_template and request.form and make no change in the remaining code ?
Can i use Jinja template after using API? or i should use javascript?
my previous solution was like this:
apps = apps_model.query.all ()
render_template ('index.html' , apps=apps)
and:
user_name = request.form ['username']

my product owner wants me to use "API" instead of above solutions
My understanding of this means that your product manager wants you to seperate the backend from the frontend. Simply put, you should create an [RESTful] API. In essence, you don't have to use render_template to process and parse the HTML templates and display it to the end user.
Your new API should return JSON objects and then, from the client side (i.e. the website), the API gets called to create, update, retrieve and delete data from the database and then return the information to the client.
from flask import Flask, jsonify
app = Flask(__name__)
app.route("/", methods=["GET"])
def index():
api_response = {
"status": "success",
"message": "Welcome to our API"
}
return jsonify(api_response)
Should i remove any render_template or request.form?
You will not be needing render_template anymore as you won't be displaying or returning HTML pages. However, request.form can still be used to collect data from the client side. Totally, depends on how you want the client to communicate with your API
Should i change my back-end and view functions completely?
Only change/create the view functions to return specific data.
Sample cases:
Get all users: create route /api/users
Get user A: create route /api/users/user_a
Am i able to just change render_template and request.form and make no change in the remaining code ?
No.
Can i use Jinja template after using API? or i should use javascript?
Very unlikely. You won't be rendering template anymore. Should I use Javascript? Certainly, for your client side.
See https://www.restapitutorial.com

May I build more than two layers of endpoint in Flask?

I know when flask builds large application, it has registered multiple blueprints.
The flask blueprint starts to initial a blueprint object, it has declared name of first layer of endpoint in the same time.
For example:
users_bp = Blueprint('users', __name__)
According to the expression, the name of first layer of endpoint of users_bp is users.
The blueprint object continues to register its view function, it has declared name of second layer of endpoint in the same time.
#users_bp.route('/login')
def login():
# do something
According to the expression, the name of second layer of endpoint of users_bp is login, it's from view name.
If I want to use endpoint to get corresponding url, I should be to do : url_for('users.login').
So it's workflow of building large application from flask tutorial. Is it right?
Let's get back on point. Is it possible to build three layers of endpoint as url_for('api. users.login')?
How do I package the blueprint or flask app to complete my wanted structure? Is it available?

You can set an endpoint within your route decorator, for example:
from flask import Flask, render_template_string
app = Flask(__name__)
#app.route('/', endpoint="this.is.the.home.endpoint")
def index():
_html="<a href='{{url_for('this.is.another.endpoint')}}'>Go to another endpoint</a>"
return render_template_string(_html)
#app.route('/another', endpoint="this.is.another.endpoint")
def another():
_html="<a href='{{url_for('this.is.the.home.endpoint')}}'>Go to the home page</a>"
return render_template_string(_html)
if __name__ == '__main__':
app.run()

What is an 'endpoint' in Flask?

The Flask documentation shows:
add_url_rule(*args, **kwargs)
Connects a URL rule. Works exactly like the route() decorator.
If a view_func is provided it will be registered with the endpoint.
endpoint – the endpoint for the registered URL rule. Flask itself assumes the name of the view function as endpoint
What exactly is meant by an "endpoint"?

How Flask Routing Works
The entire idea of Flask (and the underlying Werkzeug library) is to map URL paths to some logic that you will run (typically, the "view function"). Your basic view is defined like this:
#app.route('/greeting/<name>')
def give_greeting(name):
return 'Hello, {0}!'.format(name)
Note that the function you referred to (add_url_rule) achieves the same goal, just without using the decorator notation. Therefore, the following is the same:
# No "route" decorator here. We will add routing using a different method below.
def give_greeting(name):
return 'Hello, {0}!'.format(name)
app.add_url_rule('/greeting/<name>', 'give_greeting', give_greeting)
Let's say your website is located at 'www.example.org' and uses the above view. The user enters the following URL into their browser:
http://www.example.org/greeting/Mark
The job of Flask is to take this URL, figure out what the user wants to do, and pass it on to one of your many python functions for handling. It takes the path:
/greeting/Mark
...and matches it to the list of routes. In our case, we defined this path to go to the give_greeting function.
However, while this is the typical way that you might go about creating a view, it actually abstracts some extra info from you. Behind the scenes, Flask did not make the leap directly from URL to the view function that should handle this request. It does not simply say...
URL (http://www.example.org/greeting/Mark) should be handled by View Function (the function "give_greeting")
Actually, it there is another step, where it maps the URL to an endpoint:
URL (http://www.example.org/greeting/Mark) should be handled by Endpoint "give_greeting".
Requests to Endpoint "give_greeting" should be handled by View Function "give_greeting"
Basically, the "endpoint" is an identifier that is used in determining what logical unit of your code should handle the request. Normally, an endpoint is just the name of a view function. However, you can actually change the endpoint, as is done in the following example.
#app.route('/greeting/<name>', endpoint='say_hello')
def give_greeting(name):
return 'Hello, {0}!'.format(name)
Now, when Flask routes the request, the logic looks like this:
URL (http://www.example.org/greeting/Mark) should be handled by Endpoint "say_hello".
Endpoint "say_hello" should be handled by View Function "give_greeting"
How You Use the Endpoint
The endpoint is commonly used for the "reverse lookup". For example, in one view of your Flask application, you want to reference another view (perhaps when you are linking from one area of the site to another). Rather than hard-code the URL, you can use url_for(). Assume the following
#app.route('/')
def index():
print url_for('give_greeting', name='Mark') # This will print '/greeting/Mark'
#app.route('/greeting/<name>')
def give_greeting(name):
return 'Hello, {0}!'.format(name)
This is advantageous, as now we can change the URLs of our application without needing to change the line where we reference that resource.
Why not just always use the name of the view function?
One question that might come up is the following: "Why do we need this extra layer?" Why map a path to an endpoint, then an endpoint to a view function? Why not just skip that middle step?
The reason is because it is more powerful this way. For example, Flask Blueprints allow you to split your application into various parts. I might have all of my admin-side resources in a blueprint called "admin", and all of my user-level resources in an endpoint called "user".
Blueprints allow you to separate these into namespaces. For example...
main.py:
from flask import Flask, Blueprint
from admin import admin
from user import user
app = Flask(__name__)
app.register_blueprint(admin, url_prefix='admin')
app.register_blueprint(user, url_prefix='user')
admin.py:
admin = Blueprint('admin', __name__)
#admin.route('/greeting')
def greeting():
return 'Hello, administrative user!'
user.py:
user = Blueprint('user', __name__)
#user.route('/greeting')
def greeting():
return 'Hello, lowly normal user!'
Note that in both blueprints, the '/greeting' route is a function called "greeting". If I wanted to refer to the admin "greeting" function, I couldn't just say "greeting" because there is also a user "greeting" function. Endpoints allow for a sort of namespacing by having you specify the name of the blueprint as part of the endpoint. So, I could do the following...
print url_for('admin.greeting') # Prints '/admin/greeting'
print url_for('user.greeting') # Prints '/user/greeting'

Endpoint is the name used to reverse-lookup the url rules with url_for and it defaults to the name of the view function.
Small example:
from flask import Flask, url_for
app = Flask(__name__)
# We can use url_for('foo_view') for reverse-lookups in templates or view functions
#app.route('/foo')
def foo_view():
pass
# We now specify the custom endpoint named 'bufar'. url_for('bar_view') will fail!
#app.route('/bar', endpoint='bufar')
def bar_view():
pass
with app.test_request_context('/'):
print url_for('foo_view')
print url_for('bufar')
# url_for('bar_view') will raise werkzeug.routing.BuildError
print url_for('bar_view')

If you have same class name and want to map with multiple routes, then specify the endpoint, so that framework will differentiate between two:
class ClassName(Resource):
def get(self):
if request.endpoint!='hello':
return {"data": "Hello"}
elif:
return {"data" : "World"}
api.add_resource(ClassName, '/rout1', endpoint = "world")
api.add_resource(ClassName, '/rout2', endpoint="hello")

#app.route('/') #Endpoint
def a_function(): #View function
return 'view'
Inside Flask, every endpoint with its request methods mapped to a view function. When you use app.route decorator you are actually adding a URL rule.