2018-01-30T18:07:32Z

The Flask Mega-Tutorial Part IX: Pagination

This is the ninth installment of the Flask Mega-Tutorial series, in which I'm going to tell you how to paginate lists of database entries.

For your reference, below is a list of the articles in this series.

Note 1: If you are looking for the legacy version of this tutorial, it's here.

Note 2: If you would like to support my work on this blog, or just don't have patience to wait for weekly articles, I am offering the complete version of this tutorial packaged as an ebook or a set of videos. For more information, visit courses.miguelgrinberg.com.

In Chapter 8 I have made several database changes necessary to support the "follower" paradigm that is so popular with social networks. With that functionality in place, I'm ready to remove the last piece of scaffolding that I have put in place in the beginning, the fake posts. In this chapter the application will start accepting blog posts from users, and also deliver them in the home and profile pages.

The GitHub links for this chapter are: Browse, Zip, Diff.

Submission of Blog Posts

Let's start with something simple. The home page needs to have a form in which users can type new posts. First I create a form class:

app/forms.py: Blog submission form.

class PostForm(FlaskForm):
    post = TextAreaField('Say something', validators=[
        DataRequired(), Length(min=1, max=140)])
    submit = SubmitField('Submit')

Next, I can add this form to the template for the main page of the application:

app/templates/index.html: Post submission form in index template

{% extends "base.html" %}

{% block content %}
    <h1>Hi, {{ current_user.username }}!</h1>
    <form action="" method="post">
        {{ form.hidden_tag() }}
        <p>
            {{ form.post.label }}<br>
            {{ form.post(cols=32, rows=4) }}<br>
            {% for error in form.post.errors %}
            <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </p>
        <p>{{ form.submit() }}</p>
    </form>
    {% for post in posts %}
    <p>
    {{ post.author.username }} says: <b>{{ post.body }}</b>
    </p>
    {% endfor %}
{% endblock %}

The changes in this template are similar to how previous forms were handled. The final part is to add the form creation and handling in the view function:

app/routes.py: Post submission form in index view function.

from app.forms import PostForm
from app.models import Post

@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
@login_required
def index():
    form = PostForm()
    if form.validate_on_submit():
        post = Post(body=form.post.data, author=current_user)
        db.session.add(post)
        db.session.commit()
        flash('Your post is now live!')
        return redirect(url_for('index'))
    posts = [
        {
            'author': {'username': 'John'},
            'body': 'Beautiful day in Portland!'
        },
        {
            'author': {'username': 'Susan'},
            'body': 'The Avengers movie was so cool!'
        }
    ]
    return render_template("index.html", title='Home Page', form=form,
                           posts=posts)

Let's review the changes in this view function one by one:

  • I'm now importing the Post and PostForm classes
  • I accept POST requests in both routes associated with the index view function in addition to GET requests, since this view function will now receive form data.
  • The form processing logic inserts a new Post record into the database.
  • The template receives the form object as an additional argument, so that it can render the text field.

Before I continue, I wanted to mention something important related to processing of web forms. Notice how after I process the form data, I end the request by issuing a redirect to the home page. I could have easily skipped the redirect and allowed the function to continue down into the template rendering part, since this is already the index view function.

So, why the redirect? It is a standard practice to respond to a POST request generated by a web form submission with a redirect. This helps mitigate an annoyance with how the refresh command is implemented in web browsers. All the web browser does when you hit the refresh key is to re-issue the last request. If a POST request with a form submission returns a regular response, then a refresh will re-submit the form. Because this is unexpected, the browser is going to ask the user to confirm the duplicate submission, but most users will not understand what the browser is asking them. But if a POST request is answered with a redirect, the browser is now instructed to send a GET request to grab the page indicated in the redirect, so now the last request is not a POST request anymore, and the refresh command works in a more predictable way.

This simple trick is called the Post/Redirect/Get pattern. It avoids inserting duplicate posts when a user inadvertently refreshes the page after submitting a web form.

Displaying Blog Posts

If you recall, I created a couple of fake blog posts that I've been displaying in the home page for a long time. These fake objects are created explicitly in the index view function as a simple Python list:

    posts = [
        { 
            'author': {'username': 'John'}, 
            'body': 'Beautiful day in Portland!' 
        },
        { 
            'author': {'username': 'Susan'}, 
            'body': 'The Avengers movie was so cool!' 
        }
    ]

But now I have the followed_posts() method in the User model that returns a query for the posts that a given user wants to see. So now I can replace the fake posts with real posts:

app/routes.py: Display real posts in home page.

@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
@login_required
def index():
    # ...
    posts = current_user.followed_posts().all()
    return render_template("index.html", title='Home Page', form=form,
                           posts=posts)

The followed_posts method of the User class returns a SQLAlchemy query object that is configured to grab the posts the user is interested in from the database. Calling all() on this query triggers its execution, with the return value being a list with all the results. So I end up with a structure that is very much alike the one with fake posts that I have been using until now. It's so close that the template does not even need to change.

Making It Easier to Find Users to Follow

As I'm sure you noticed, the application as it is does not do a great job at letting users find other users to follow. In fact, there is actually no way to see what other users are there at all. I'm going to address that with a few simple changes.

I'm going to create a new page that I'm going to call the "Explore" page. This page will work like the home page, but instead of only showing posts from followed users, it will show a global post stream from all users. Here is the new explore view function:

app/routes.py: Explore view function.

@app.route('/explore')
@login_required
def explore():
    posts = Post.query.order_by(Post.timestamp.desc()).all()
    return render_template('index.html', title='Explore', posts=posts)

Did you notice something odd in this view function? The render_template() call references the index.html template, which I'm using in the main page of the application. Since this page is going to be very similar to the main page, I decided to reuse the template. But one difference with the main page is that in the explore page I do not want to have a form to write blog posts, so in this view function I did not include the form argument in the template call.

To prevent the index.html template from crashing when it tries to render a web form that does not exist, I'm going to add a conditional that only renders the form if it is defined:

app/templates/index.html: Make the blog post submission form optional.

{% extends "base.html" %}

{% block content %}
    <h1>Hi, {{ current_user.username }}!</h1>
    {% if form %}
    <form action="" method="post">
        ...
    </form>
    {% endif %}
    ...
{% endblock %}

I'm also going to add a link to this new page in the navigation bar:

app/templates/base.html: Link to explore page in navigation bar.

        <a href="{{ url_for('explore') }}">Explore</a>

Remember the _post.html sub-template that I have introduced in Chapter 6 to render blog posts in the user profile page? This was a small template that was included from the user profile page template, and was separate so that it can also be used from other templates. I'm now going to make a small improvement to it, which is to show the username of the blog post author as a link:

app/templates/_post.html: Show link to author in blog posts.

    <table>
        <tr valign="top">
            <td><img src="{{ post.author.avatar(36) }}"></td>
            <td>
                <a href="{{ url_for('user', username=post.author.username) }}">
                    {{ post.author.username }}
                </a>
                says:<br>{{ post.body }}
            </td>
        </tr>
    </table>

I can now use this sub-template to render blog posts in the home and explore pages:

app/templates/index.html: Use blog post sub-template.

    ...
    {% for post in posts %}
        {% include '_post.html' %}
    {% endfor %}
    ...

The sub-template expects a variable named post to exist, and that is how the loop variable in the index template is named, so that works perfectly.

With these small changes, the usability of the application has improved considerably. Now a user can visit the explore page to read blog posts from unknown users and based on those posts find new users to follow, which can be done by simply clicking on a username to access the profile page. Amazing, right?

At this point I suggest you try the application once again, so that you experience these last user interface improvements.

Blog Posts

Pagination of Blog Posts

The application is looking better than ever, but showing all of the followed posts in the home page is going to become a problem sooner rather than later. What happens if a user has a thousand followed posts? Or a million? As you can imagine, managing such a large list of posts will be extremely slow and inefficient.

To address that problem, I'm going to paginate the post list. This means that initially I'm going to show just a limited number of posts at a time, and include links to navigate through the entire list of posts. Flask-SQLAlchemy supports pagination natively with the paginate() query method. If for example, I want to get the first twenty followed posts of the user, I can replace the all() call that terminates the query with:

>>> user.followed_posts().paginate(1, 20, False).items

The paginate method can be called on any query object from Flask-SQLAlchemy. It takes three arguments:

  • the page number, starting from 1
  • the number of items per page
  • an error flag. If True, when an out of range page is requested a 404 error will be automatically returned to the client. If False, an empty list will be returned for out of range pages.

The return value from paginate is a Pagination object. The items attribute of this object contains the list of items in the requested page. There are other useful things in the Pagination object that I will discuss later.

Now let's think about how I can implement pagination in the index() view function. I can start by adding a configuration item to the application that determines how many items will be displayed per page.

config.py: Posts per page configuration.

class Config(object):
    # ...
    POSTS_PER_PAGE = 3

It is a good idea to have these application-wide "knobs" that can change behaviors in the configuration file, because then I can go to a single place to make adjustments. In the final application I will of course use a larger number than three items per page, but for testing it is useful to work with small numbers.

Next, I need to decide how the page number is going to be incorporated into application URLs. A fairly common way is to use a query string argument to specify an optional page number, defaulting to page 1 if it is not given. Here are some example URLs that show how I'm going to implement this:

  • Page 1, implicit: http://localhost:5000/index
  • Page 1, explicit: http://localhost:5000/index?page=1
  • Page 3: http://localhost:5000/index?page=3

To access arguments given in the query string, I can use the Flask's request.args object. You have seen this already in Chapter 5, where I implemented user login URLs from Flask-Login that can include a next query string argument.

Below you can see how I added pagination to the home and explore view functions:

app/routes.py: Followers association table

@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
@login_required
def index():
    # ...
    page = request.args.get('page', 1, type=int)
    posts = current_user.followed_posts().paginate(
        page, app.config['POSTS_PER_PAGE'], False)
    return render_template('index.html', title='Home', form=form,
                           posts=posts.items)

@app.route('/explore')
@login_required
def explore():
    page = request.args.get('page', 1, type=int)
    posts = Post.query.order_by(Post.timestamp.desc()).paginate(
        page, app.config['POSTS_PER_PAGE'], False)
    return render_template("index.html", title='Explore', posts=posts.items)

With these changes, the two routes determine the page number to display, either from the page query string argument or a default of 1, and then use the paginate() method to retrieve only the desired page of results. The POSTS_PER_PAGE configuration item that determines the page size is accessed through the app.config object.

Note how easy these changes are, and how little code is affected each time a change is made. I am trying to write each part of the application without making any assumptions about how the other parts work, and this enables me to write modular and robust applications that are easier to extend and to test, and are less likely to fail or have bugs.

Go ahead and try the pagination support. First make sure you have more than three blog posts. This is easier to see in the explore page, which shows posts from all users. You are now going to see just the three most recent posts. If you want to see the next three, type http://localhost:5000/explore?page=2 in your browser's address bar.

Page Navigation

The next change is to add links at the bottom of the blog post list that allow users to navigate to the next and/or previous pages. Remember that I mentioned that the return value from a paginate() call is an object of a Pagination class from Flask-SQLAlchemy? So far, I have used the items attribute of this object, which contains the list of items retrieved for the selected page. But this object has a few other attributes that are useful when building pagination links:

  • has_next: True if there is at least one more page after the current one
  • has_prev: True if there is at least one more page before the current one
  • next_num: page number for the next page
  • prev_num: page number for the previous page

With these four elements, I can generate next and previous page links and pass them down to the templates for rendering:

app/routes.py: Next and previous page links.

@app.route('/', methods=['GET', 'POST'])
@app.route('/index', methods=['GET', 'POST'])
@login_required
def index():
    # ...
    page = request.args.get('page', 1, type=int)
    posts = current_user.followed_posts().paginate(
        page, app.config['POSTS_PER_PAGE'], False)
    next_url = url_for('index', page=posts.next_num) \
        if posts.has_next else None
    prev_url = url_for('index', page=posts.prev_num) \
        if posts.has_prev else None
    return render_template('index.html', title='Home', form=form,
                           posts=posts.items, next_url=next_url,
                           prev_url=prev_url)

 @app.route('/explore')
 @login_required
 def explore():
    page = request.args.get('page', 1, type=int)
    posts = Post.query.order_by(Post.timestamp.desc()).paginate(
        page, app.config['POSTS_PER_PAGE'], False)
    next_url = url_for('explore', page=posts.next_num) \
        if posts.has_next else None
    prev_url = url_for('explore', page=posts.prev_num) \
        if posts.has_prev else None
    return render_template("index.html", title='Explore', posts=posts.items,
                          next_url=next_url, prev_url=prev_url)

The next_url and prev_url in these two view functions are going to be set to a URL returned by url_for() only if there is a page in that direction. If the current page is at one of the ends of the collection of posts, then the has_next or has_prev attributes of the Pagination object will be False, and in that case the link in that direction will be set to None.

One interesting aspect of the url_for() function that I haven't discussed before is that you can add any keyword arguments to it, and if the names of those arguments are not referenced in the URL directly, then Flask will include them in the URL as query arguments.

The pagination links are being set to the index.html template, so now let's render them on the page, right below the post list:

app/templates/index.html: Render pagination links on the template.

    ...
    {% for post in posts %}
        {% include '_post.html' %}
    {% endfor %}
    {% if prev_url %}
    <a href="{{ prev_url }}">Newer posts</a>
    {% endif %}
    {% if next_url %}
    <a href="{{ next_url }}">Older posts</a>
    {% endif %}
    ...

This change adds to link below the post list on both the index and explore pages. The first link is labeled "Newer posts", and it points to the previous page (keep in mind I'm showing posts sorted by newest first, so the first page is the one with the newest content). The second link is labeled "Older posts" and points to the next page of posts. If any of these two links is None, then it is omitted from the page, through a conditional.

Pagination

Pagination in the User Profile Page

The changes for the index page are sufficient for now. However, there is also a list of posts in the user profile page, which shows only posts from the owner of the profile. To be consistent, the user profile page should be changed to match the pagination style of the index page.

I begin by updating the user profile view function, which still had a list of fake post objects in it.

app/routes.py: Pagination in the user profile view function.

@app.route('/user/<username>')
@login_required
def user(username):
    user = User.query.filter_by(username=username).first_or_404()
    page = request.args.get('page', 1, type=int)
    posts = user.posts.order_by(Post.timestamp.desc()).paginate(
        page, app.config['POSTS_PER_PAGE'], False)
    next_url = url_for('user', username=user.username, page=posts.next_num) \
        if posts.has_next else None
    prev_url = url_for('user', username=user.username, page=posts.prev_num) \
        if posts.has_prev else None
    return render_template('user.html', user=user, posts=posts.items,
                           next_url=next_url, prev_url=prev_url)

To get the list of posts from the user, I take advantage of the fact that the user.posts relationship is a query that is already set up by SQLAlchemy as a result of the db.relationship() definition in the User model. I take this query and add a order_by() clause so that I get the newest posts first, and then do the pagination exactly like I did for the posts in the index and explore pages. Note that the pagination links that are generated by the url_for() function need the extra username argument, because they are pointing back at the user profile page, which has this username as a dynamic component of the URL.

Finally, the changes to the user.html template are identical to those I made on the index page:

app/templates/user.html: Pagination links in the user profile template.

    ...
    {% for post in posts %}
        {% include '_post.html' %}
    {% endfor %}
    {% if prev_url %}
    <a href="{{ prev_url }}">Newer posts</a>
    {% endif %}
    {% if next_url %}
    <a href="{{ next_url }}">Older posts</a>
    {% endif %}

After you are done experiment with the pagination feature, you can set the POSTS_PER_PAGE configuration item to a more reasonable value:

config.py: Posts per page configuration.

class Config(object):
    # ...
    POSTS_PER_PAGE = 25

59 comments

  • #1 Daniel said 2018-02-07T08:05:46Z

    Hi, Miguel! I got a problem where // post = Post(body=form.post.data, author=current_user) //. This is located in routes/index. The problems seems to be that models/Post doesnt have a author attribute but you didnt specifie that it should in your models.py file. Any idéa?

  • #2 Miguel Grinberg said 2018-02-08T13:52:14Z

    @Daniel: The Post models does have a "author" attribute. This is specified in the User model's relationship construct. The "backref" argument there defines the other side of the relationship, from posts to users. Go back to chapter 4 to see this.

  • #3 Petronilla said 2018-02-09T02:37:16Z

    Hi Miguel, Thank you for this blog one more time. I have one question. In some websites/blogs I have seen that only the title and part of the first paragraph are displaced as it fades away, may be for 10 blogs on each page. Then there is either a button to read the entire blog, or clicking on the title will display the single blog entirely perhaps with pagination. How is such implementation different from the one you have shown? Thank you.

  • #4 Miguel Grinberg said 2018-02-09T04:56:28Z

    @Petronilla: the pagination is exactly the same. What changes is that each blog article has a summary that is displayed instead of the complete article. The summary can be generated algorithmically, for example by showing the first N characters of the article, or can also be an additional field in the model. The title of the blog post can be a link that takes the user to a page for the blog post, where the complete article is shown.

  • #5 Serhiy said 2018-02-12T17:17:01Z

    Hi, Miguel, In a user profile page we don't need links for this same user profile (as well as "this user says:") which this page gets from "_post.html". So it would be reasonable to pass additional parameter (hide link: boolean) or create one more sub_template

  • #6 Miguel Grinberg said 2018-02-12T21:11:35Z

    @Serhiy: It should be fairly easy to implement what you describe. All the concepts that you need to do that were already covered in this tutorial.

  • #7 Anthony said 2018-02-27T03:48:50Z

    Hi Miguel, Thanks a lot for putting this tutorial together, I'm really learning a lot of new things about Flask. The question I had about the pagination chapter was regarding the explore link. When I login as a user and click the explore link, it displays the list of post and then there's the link for older posts without displaying the form to enter a new post which is expected. When I click on the "older" link to this display more posts, the form then becomes visible. I was wondering if this is expected?

  • #8 Miguel Grinberg said 2018-02-27T07:05:42Z

    @Anthony: The Home page has the form, the Explore page does not. Sounds like the "Older Posts" link in the Explore page is incorrectly linking to the Home page. Check the pagination links in the Explore view function and make sure they are correct.

  • #9 Vishal said 2018-03-18T02:43:04Z

    Hi Miguel, Thank you for the tutorial. How app.config['POSTS_PER_PAGE'] works? Shouldn't it be like app.config.POSTS_PER_PAGE because it is a class variable and not a dictionary.

  • #10 Miguel Grinberg said 2018-03-18T06:09:37Z

    @Vishal: No. You are confusing the Config class (which has the configuration given as class variables) with the app.config object, which is Flask's configuration object. The app.config object uses dictionary syntax for configuration variables, regardless of how those were imported into the application.

  • #11 Boudhayan said 2018-03-27T15:18:22Z

    Hi, thank you for the wonderful tutorial series. I have a doubt which I believe I should have asked much earlier in the series but nevertheless here it is. So I have noticed that you used "render_template" to load a web page for the first time and "redirect" , to load the same/diff page after some processing like form filling etc. has taken place. Can you explain the difference between the two in terms of functionality only ? I have searched online for solutions where they explained the difference being that of only status codes i.e 320 and 200. I wanted to know, if I can use render_template in place of redirect as both seem to provide the same functionality. Again, many thanks for the great tutorial series.

  • #12 Boudhayan said 2018-03-27T17:17:42Z

    Hello Miguel, thank you for the wonderful tutorial. I have a question regarding the 'posts' feature. So, I have seen few social media sites like Facebook etc which allows a user to post on another user's wall. And these posts are visible only to the user who posted and the one on whose wall it is posted on. Other users, who maybe be mutual friends/followers do not get those updates on their wall. If I had to implement the same, how would I go about it ? Say, A,B,C are following each other and B posts on C wall. That post should not be visible on A's wall (home section). Is there a way to implement this with the current database model or should I create another model class with relevant headers to implement the same ?

  • #13 Miguel Grinberg said 2018-03-27T21:56:27Z

    @Boudhayan: for your first question, that is actually covered in this article, search for "post/redirect/get" to find the place. Your second question it seems you are asking about something more or less similar to private messages, which is a feature that is covered later in this tutorial. If you wanted these private messages to be mixed with the user's timeline, you would need to expand the query for posts to also include these messages.

  • #14 dhanunjaya said 2018-04-16T06:48:41Z

    <td><img src="{{ post.author.avatar(36) }}"></td> <td> <a href="{{ url_for('user', username = post.author.username ) }}">{{ post.author.username }}</a> says:<b>{{ post.body }}</b> </td> </tr> jinja2.exceptions.UndefinedError: 'None' has no attribute 'avatar'

  • #15 Miguel Grinberg said 2018-04-16T17:53:44Z

    @dhanunjaya: you have a post in your database that has its author set to None. Fix that and you should be fine.

  • #16 Bernd Bausch said 2018-04-20T07:14:35Z

    You say "Calling all() on this query triggers its execution". By mistake, I left all() out, for example "posts = current_user.followed_posts()" instead of "posts = current_user.followed_posts().all()". And it seems to work just the same. Without the all(), I can see that a "flask_sqlalchemy.BaseQuery object" is returned. With the all(), I get a simple list of posts. Both the BaseQuery object and the list are iterable and yield the same posts when I iterate over them. To exclude cacheing effects, I manually inserted a post in the database, circumventing my app and SQLAlchemy. Even that turned up when running the query without all(). So, what's happening here? Obviously, SQLAlchemy accesses the DB even if I don't add all(). What's it for, then?

  • #17 dhanunjaya said 2018-04-20T11:35:13Z

    sir, <td><img src="{{ post.author.avatar(36) }}"></td> <td> <a href="{{ url_for('user', username = post.author.username ) }}">{{ post.author.username }}</a> says:<b>{{ post.body }}</b> </td> </tr> {{ post.author.username }} --->> works fine it returns post author name, but i am getting an error: jinja2.exceptions.UndefinedError: 'None' has no attribute 'avatar' while calling {{ post.author.avatar(70) }} this is my stack trace : File "/home/dj/Documents/microblog/app/templates/index.html", line 12, in block "app_content" {% if form %} {{ wtf.quick_form(form) }} <br> {% endif %} {% for post in posts %} {% include '_post.html' %} {% endfor %} <nav aria-label="..."> <ul class="pager"> File "/home/dj/Documents/microblog/app/templates/_post.html", line 5, in top-level template code <img src="{{ post.author.avatar(70) }}" /> </a> </td> <td> <a href="{{ url_for('user', username=post.author.username) }}">{{ post.author.username }}</a> jinja2.exceptions.UndefinedError: 'None' has no attribute 'avatar' I have verified all the code but i could not solve this error. can you please help me ########### routes.py ######## @app.route('/explore') @login_required def explore(): page = request.args.get('page', 1, type=int) posts = Post.query.order_by(Post.timestamp.desc()).paginate( page, app.config['POSTS_PER_PAGE'], False) next_url = url_for('explore', page=posts.next_num) \ if posts.has_next else None prev_url = url_for('explore', page=posts.prev_num) \ if posts.has_prev else None return render_template('index.html', title='Explore', posts=posts.items, next_url=next_url, prev_url=prev_url) ########### templates/index.html ############# {% extends "base.html"%} {% import 'bootstrap/wtf.html' as wtf %} {% block app_content %} <h1>Hi, {{ current_user.username }}!</h1> {% if form %} {{ wtf.quick_form(form) }} <br> {% endif %} {% for post in posts %} {% include '_post.html' %} {% endfor %} <nav aria-label="..."> <ul class="pager"> <li class="previous{% if not prev_url %} disabled{% endif %}"> <a href="{{ prev_url or '#' }}"> <span aria-hidden="true">&larr;</span> Newer posts </a> </li> <li class="next{% if not next_url %} disabled{% endif %}"> <a href="{{ next_url or '#' }}"> Older posts <span aria-hidden="true">&rarr;</span> </a> </li> </ul> </nav> {% endblock %} ######### templates/_post.html ########### <table class="table table-hover"> <tr> <td width="70px"> <a href="{{ url_for('user', username = post.author.username ) }}"> <img src="{{ post.author.avatar(70) }}" /> </a> </td> <td> <a href="{{ url_for('user', username=post.author.username) }}"> {{ post.author.username }}</a> says: <br> {{ post.body }} </td> </tr> </table> ############## models.py ############## followers = db.Table('followers', db.Column('follower_id', db.Integer, db.ForeignKey('users.id')), db.Column('followed_id', db.Integer, db.ForeignKey('users.id')) ) class User(UserMixin, db.Model): __tablename__="users" id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True, index=True) email = db.Column(db.String(120), unique=True, index=True) password_hash=db.Column(db.String(128)) posts = db.relationship('Post', backref='author', lazy='dynamic') about_me=db.Column(db.String(140)) last_seen = db.Column(db.DateTime, default=datetime.utcnow) followed = db.relationship( 'User', secondary = followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin = (followers.c.followed_id == id), backref = db.backref('followers', lazy='dynamic'), lazy='dynamic' ) def __repr__(self): return "<user : {}>.".format(self.username) def set_password(self, password): self.password_hash=generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password) def avatar(self, size): digest=md5(self.email.lower().encode('utf-8')).hexdigest() return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format(digest, size) .......................... ................................ class Post(UserMixin, db.Model): __tablename__='posts' id=db.Column(db.Integer, primary_key=True) body=db.Column(db.String(140)) timestamp = db.Column(db.DateTime, index=True, default=datetime.utcnow) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) def __repr__(self): return "<post {}>".format(self.body)

  • #18 Miguel Grinberg said 2018-04-22T06:47:25Z

    @Bernd: You are correct. The query object is an iterable, so instead of calling all() on it you can also do list(query), or just loop over the results with something like "for result in query". Either of these will execute the query and return the results.

  • #19 Miguel Grinberg said 2018-04-22T06:52:24Z

    @dhanunjaya: you have a post in your database that does not have an author assigned.

  • #20 OMAR GUTIERREZ said 2018-04-25T00:25:51Z

    Hola Miguel. This flask tutorial is amazing, both the content and your teaching methods seem superb to me, I am using this as a basis to make a web page that saves the info from forms with several fields to them on MySQL. There's an issue I don't know how to solve and would love your guidance. It involves the users losing the information typed so far in the middle of or after filling the form if they forget to press the save button or have a power shortage, I am thinking on implementing an auto save feature every X minutes. If you feel this falls under the scope on the tutorial's questions would you please point me in the right direction on how to implement this? Thanks a ton in advance for the guidance and your wonderful tutorial.

  • #21 Miguel Grinberg said 2018-04-25T01:25:10Z

    @Omar: Doing what you want requires some JavaScript work. You need to install a function that runs at regular intervals, reads all the form fields, and submits them to the server to be saved.

  • #22 OMAR GUTIERREZ said 2018-04-25T19:16:27Z

    Thanks a bunch! First time I face this issue and was kinda lost on the plethora of methods you can do to get the same result when programming web apps. I'll get to do that maestro Miguel.

  • #23 Rohan said 2018-04-30T19:09:23Z

    Hi Miguel, Is there an easy way to create pagination links for the first and last pages? Something like: page=posts.first_num page=posts.last_num Thank you.

  • #24 Miguel Grinberg said 2018-05-02T05:07:49Z

    @Rohan: consult the Pagination object documentation here: http://flask-sqlalchemy.pocoo.org/2.3/api/#flask_sqlalchemy.Pagination. There are more attributes that tell you the first and last pages.

  • #25 Tiago said 2018-05-09T02:37:07Z

    Hi Miguel Now that you mention the Post/Redirect/Get pattern, I had noticed that when we submit a form with invalid data and get those red error messages, once we refresh the page it gives that browser warning about re-submitting the form. Looking at the code, I see this is because on that particular event, the code is skipping the form.validate_on_submit() code block which includes the redirect() call. I tried fixing it with the code below (for the index entry point) but now the error messages disappear, I guess the redirect flushes the errors out. def index(): form = PostForm() if form.validate_on_submit(): post = Post(body=form.post.data, author=current_user) db.session.add(post) db.session.commit() flash('Your post is now live!') if request.method == 'POST': return redirect(url_for('index')) # ... How can we get the error messages displayed, but still apply the Post/Redirect/Get pattern in this situation? Thanks! Tiago

Leave a Comment