Qu'est-ce qu'un « point de terminaison » dans Flask?

Question

La documentation de Flask montre:

add_url_rule(*args, **kwargs)
      Connecte une règle d'URL. Fonctionne exactement comme le décorateur route().
      Si une view_func est fournie, elle sera enregistrée avec le endpoint.

     endpoint – le endpoint pour la règle d'URL enregistrée. Flask suppose lui-même le nom de la fonction de vue comme endpoint

Que signifie exactement un "endpoint"?

Answer 1

Comment fonctionne le routage Flask

L'idée entière de Flask (et de la bibliothèque sous-jacente Werkzeug) est de mapper les chemins URL à une certaine logique que vous exécuterez (généralement, la "fonction de vue"). Votre vue de base est définie comme ceci :

@app.route('/greeting/')
def give_greeting(name):
    return 'Bonjour, {0}!'.format(name)

Remarquez que la fonction à laquelle vous avez fait référence (add_url_rule) réalise le même objectif, juste sans utiliser la notation du décorateur. Par conséquent, ce qui suit est la même chose :

# Pas de décorateur "route" ici. Nous allons ajouter le routage en utilisant une méthode différente ci-dessous.
def give_greeting(name):
    return 'Bonjour, {0}!'.format(name)

app.add_url_rule('/greeting/', 'give_greeting', give_greeting)

Disons que votre site Web est situé à 'www.example.org' et utilise la vue ci-dessus. L'utilisateur entre l'URL suivante dans son navigateur :

http://www.example.org/greeting/Mark

Le rôle de Flask est de prendre cette URL, de comprendre ce que l'utilisateur veut faire, et de le transmettre à l'une de vos nombreuses fonctions Python pour le traitement. Il prend le chemin :

/greeting/Mark

...et l'associe à la liste des chemins. Dans notre cas, nous avons défini ce chemin pour aller à la fonction give_greeting.

Cependant, bien que ce soit la manière typique dont vous pourriez créer une vue, cela abstrait en fait des informations supplémentaires. En coulisses, Flask n'a pas franchi directement le pas de l'URL à la fonction de vue qui devrait gérer cette demande. Il ne dit pas simplement...

URL (http://www.example.org/greeting/Mark) devrait être gérée par la Fonction de Vue (la fonction "give_greeting")

En réalité, il y a une autre étape, où il mappe l'URL à un point d'extrémité :

URL (http://www.example.org/greeting/Mark) devrait être gérée par le Point d'Extrémité "give_greeting".
Les requêtes à l'Extrémité "give_greeting" devraient être gérées par la Fonction de Vue "give_greeting"

Fondamentalement, le "point d'extrémité" est un identifiant qui est utilisé pour déterminer quelle unité logique de votre code devrait gérer la demande. Normalement, un point d'extrémité est simplement le nom d'une fonction de vue. Cependant, vous pouvez réellement changer le point d'extrémité, comme dans l'exemple suivant.

@app.route('/greeting/', endpoint='say_hello')
def give_greeting(name):
    return 'Bonjour, {0}!'.format(name)

Maintenant, lorsque Flask route la demande, la logique ressemble à ceci :

URL (http://www.example.org/greeting/Mark) devrait être gérée par le Point d'Extrémité "say_hello".
L'Extrémité "say_hello" devrait être gérée par la Fonction de Vue "give_greeting"

Comment utiliser le point d'extrémité

Le point d'extrémité est couramment utilisé pour la "recherche inverse". Par exemple, dans une vue de votre application Flask, vous voulez faire référence à une autre vue (peut-être lorsque vous liez un domaine du site à un autre). Au lieu de coder en dur l'URL, vous pouvez utiliser url_for(). Supposons ce qui suit

@app.route('/')
def index():
    print url_for('give_greeting', name='Mark') # Cela affichera '/greeting/Mark'

@app.route('/greeting/')
def give_greeting(name):
    return 'Bonjour, {0}!'.format(name)

C'est avantageux, car maintenant nous pouvons changer les URL de notre application sans avoir besoin de modifier la ligne où nous faisons référence à cette ressource.

Pourquoi ne pas toujours utiliser le nom de la fonction de vue ?

Une question qui pourrait se poser est la suivante : "Pourquoi avons-nous besoin de cette couche supplémentaire ?" Pourquoi associer un chemin à un point d'extrémité, puis un point d'extrémité à une fonction de vue ? Pourquoi ne pas simplement sauter cette étape intermédiaire ?

La raison en est qu'il est plus puissant de cette manière. Par exemple, les Blueprints Flask vous permettent de diviser votre application en différentes parties. Je pourrais avoir toutes mes ressources côté administrateur dans un blueprint appelé "admin", et toutes mes ressources au niveau de l'utilisateur dans un point d'extrémité appelé "user".

Les Blueprints vous permettent de séparer ces éléments en espaces de noms. Par exemple...

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 'Bonjour, utilisateur administratif!'

user.py :

user = Blueprint('user', __name__)
@user.route('/greeting')
def greeting():
    return 'Bonjour, simple utilisateur!'

Remarquez que dans les deux blueprints, le chemin '/greeting' est une fonction appelée "greeting". Si je voulais faire référence à la fonction "greeting" de l'admin, je ne pourrais pas simplement dire "greeting" car il y a aussi une fonction "greeting" de l'utilisateur. Les points d'extrémité permettent une sorte d'espacement des noms en vous permettant de spécifier le nom du blueprint comme partie du point d'extrémité. Ainsi, je pourrais faire ce qui suit...

print url_for('admin.greeting') # Affiche '/admin/greeting'
print url_for('user.greeting') # Affiche '/user/greeting'

Answer 2

EndPoint est le nom utilisé pour effectuer une recherche inversée des règles d'URL avec url_for et il est par défaut le nom de la fonction de vue.

Petit exemple :

from flask import Flask, url_for

app = Flask(__name__)

# Nous pouvons utiliser url_for('foo_view') pour des recherches inversées dans les templates ou les fonctions de vue
@app.route('/foo')
def foo_view():
    pass

# Nous spécifions maintenant le point final personnalisé nommé 'bufar'. url_for('bar_view') échouera !
@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') lèvera une erreur de werkzeug.routing.BuildError
    print url_for('bar_view')

Answer 3

Si vous avez le même nom de classe et que vous souhaitez mapper avec plusieurs routes, alors spécifiez le point de terminaison, afin que le framework fasse la différence entre les deux:

 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")

Answer 4

@app.route('/')     #Point de terminaison
def une_fonction():   #Fonction de vue
    return 'vue'

À l'intérieur de Flask, chaque point de terminaison avec ses méthodes de requête est mappé vers une fonction de vue. Lorsque vous utilisez le décorateur app.route, vous ajoutez en fait une règle d'URL.