Table of Contents
- Introduction
- Prerequisites
- Setting Up Flask
- Creating the Flask App
- Building the HTML Template
- Fetching Content from RSS Feeds
- Displaying the Aggregated Content
- Conclusion
Introduction
In this tutorial, we will learn how to build a content aggregator site using Flask, a popular web framework for Python. A content aggregator site collects information from multiple sources, such as RSS feeds, and displays them in a single location. By the end of this tutorial, you will be able to create your own content aggregator site and fetch content from multiple sources.
Prerequisites
Before getting started, you should have a basic understanding of Python programming language and HTML. You will also need to have Python and Flask installed on your computer. If you haven’t installed Flask yet, you can do so by running the following command:
pip install flask
Setting Up Flask
To begin, let’s create a new directory for our project. Open your terminal and navigate to the directory where you want to create the project. Then, run the following command to create a new directory:
mkdir content-aggregator && cd content-aggregator
Next, create a virtual environment for our project by running the following command:
python -m venv venv
Activate the virtual environment by running the appropriate command for your operating system:
For Windows:
venv\Scripts\activate
For macOS/Linux:
source venv/bin/activate
Creating the Flask App
Now that we have our virtual environment set up, let’s create a new Python file called app.py to serve as our Flask application. Open your preferred text editor and create the following file structure:
content-aggregator/
└── venv/
└── app.py
In the app.py file, add the following code to create a basic Flask application:
```python
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return "Hello, world!"
if __name__ == '__main__':
app.run()
``` Save the file and return to your terminal. Make sure you're still in the `content-aggregator` directory and run the following command to start the Flask development server:
```
python app.py
``` You should see an output similar to the following:
```
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
``` This means that your Flask application is now running locally. Open your web browser and navigate to `http://localhost:5000` to see the "Hello, world!" message displayed.
Building the HTML Template
Now that we have our Flask app running, let’s create an HTML template to display the aggregated content. Create a new directory called templates within the content-aggregator directory:
content-aggregator/
└── templates/
| └── index.html
└── venv/
└── app.py
Inside the templates directory, create a new file called index.html and add the following code:
```html
<!DOCTYPE html>
<html>
<head>
<li></li>
<li></li>
<li></li>
</ul>
</body>
</html>
``` This HTML template will serve as the main page for our content aggregator site. It will display a title and a list of aggregated content items.
Fetching Content from RSS Feeds
To fetch content from RSS feeds, we will use the feedparser library. Install it by running the following command:
pip install feedparser
In your app.py file, import the feedparser module and add the following code below the Flask app routes:
```python
import feedparser
@app.route('/aggregate')
def aggregate():
# URLs of RSS feeds to fetch
feed_urls = [
'https://example.com/feed1.xml',
'https://example.com/feed2.xml',
'https://example.com/feed3.xml'
]
content = []
for url in feed_urls:
feed = feedparser.parse(url)
for entry in feed.entries:
content.append({
'title': entry.title,
'description': entry.description,
'link': entry.link
})
return render_template('index.html', content=content)
``` In this code, we import the `feedparser` module and define a new route `/aggregate` that will fetch content from the specified RSS feed URLs. We iterate through each feed and its entries, extracting the title, description, and link of each entry. We store this information in the `content` list. Finally, we render the `index.html` template and pass the `content` list as a variable.
Displaying the Aggregated Content
To display the aggregated content on the home page of our application, we need to update the home route in the app.py file to fetch the content from the /aggregate route. Modify the code as follows:
```python
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def home():
return redirect('/aggregate')
@app.route('/aggregate')
def aggregate():
# Fetch content from RSS feeds...
return render_template('index.html', content=content)
if __name__ == '__main__':
app.run()
``` In this code, we import the `render_template` function from Flask and update the `home` route to redirect to the `/aggregate` route. This way, when a user visits the home page, they will automatically be redirected to the page that displays the aggregated content.
Conclusion
Congratulations! You have successfully built a content aggregator site using Flask. You learned how to set up a Flask application, create HTML templates, fetch content from RSS feeds, and display the aggregated content on a web page. You can now expand on this project by adding more features, such as filtering content by category or implementing user authentication. Flask provides a flexible and powerful framework for web development with Python, and you are now equipped with the knowledge to create your own dynamic web applications. Happy coding!