Forem: Graham Patrick

Why I Built Flaskion — And Where It’s Headed

Graham Patrick — Tue, 15 Apr 2025 13:56:09 +0000

About 7 years ago, I was looking to move beyond PHP. I’d spent years building with it, and while it had served me well, I knew I wanted something more modern and flexible — something that felt exciting again.

Naturally, I began exploring Node.js and the growing JavaScript ecosystem. But as powerful as it was, something didn’t quite click for me. I started to feel like I was forcing myself into a stack that didn’t align with how I thought about building applications.

Then I found Python.

My Python Journey

I enrolled in the Python Techdegree from Treehouse and immediately felt at home. Python’s clarity, community, and flexibility felt like a breath of fresh air.

Soon after, I discovered Flask — a minimal web framework with just enough power to get things done. And I loved it… at first.

But as I built more apps, one thing became very clear:

Flask gives you freedom — but it also gives you zero structure.

I was constantly deciding how to structure folders, where to put my routes, how to separate views from logic, whether to use Blueprints, how to manage environment variables, how to write tests… the list goes on.

For solo projects, it was manageable. But when working with others, or revisiting older codebases, I’d get lost in my own inconsistency.

So I Built Flaskion

Flaskion was born from frustration — and love.

It’s a Laravel-inspired MVC boilerplate for Flask. Clean, structured, and focused on making your development process feel purposeful and productive.

With Flaskion, you get:

A predictable folder structure

Built-in CLI to scaffold models, controllers, schemas, and full MVC stacks
Auto-registered routes (web + API)
A templating-friendly controller setup using render_template
Now: a custom database migration system, with multi-engine support for SQLite, MySQL, and Postgres And more to come…

This isn’t just a boilerplate. I’m building a micro-framework on top of Flask — and I’m training others to use it.

What’s Next

A full documentation site
Courses and tutorials (starting with FlaskCast)
A community around Flaskion for people who want structure without the bloat
Migration engine + seeding + validation
A clean authentication scaffold
Advanced CLI tools like make:resource, make:test, and migrate:refresh

Why This Matters

Flask is amazing. But if you’ve ever felt overwhelmed by the “do anything, however you want” freedom of it — Flaskion is for you.

It’s opinionated (but not bossy), flexible (but not vague), and growing fast.

Flaskion is available now:

pipx install flaskion-cli

flaskion new myproject

If you’ve ever felt the same way about Flask, or you’ve been looking for structure in your Python web journey, I’d love your thoughts — or even your contributions.

Let’s build something better, together.

What is FMV Stack?

Graham Patrick — Wed, 14 Feb 2024 07:04:52 +0000

If you are looking for a modern and powerful way to create dynamic web applications, you might want to consider using the FMV Stack, which stands for Flask, Vue.js, and MySQL.

What is FMV Stack?

Flask: A lightweight and flexible Python web framework that provides the backend logic and RESTful API for our app.
Vue.js: A progressive and reactive JavaScript framework that handles the frontend user interface and interaction with the backend API.
MySQL: A reliable and scalable relational database system that stores and retrieves the data for our app.

There are many benefits of using FMV Stack for web development, such as:

Simplicity: Flask and Vue.js are both easy to learn and use, with clear and concise syntax and documentation. They also have a large and active community that provides support and resources.
Flexibility: Flask and Vue.js are both unopinionated and modular, meaning that they do not enforce a specific way of doing things and allow you to choose the tools and libraries that suit your needs. You can also easily integrate them with other technologies and services.
Performance: Flask and Vue.js are both fast and efficient, with minimal overhead and high scalability. They also support asynchronous and concurrent programming, which improves the responsiveness and user experience of the app.
Compatibility: Flask and Vue.js are both cross-platform and cross-browser compatible, meaning that they can run on any operating system and device, and work with any modern web browser.

How to build a web app with FMV Stack?

To build a web app with FMV Stack, we need to follow these steps:

Set up the development environment and install the required dependencies.
Create the database schema and tables using MySQL.
Design the backend API using Flask and Flask-RESTful.
Implement the database operations using SQLAlchemy and Flask-Migrate.
Test the backend API using Postman or curl.
Create the frontend project using Vue CLI and configure the settings.
Design the frontend components using Vue.js and Bootstrap-Vue.
Implement the frontend logic using Axios and Vuex.
Test the frontend functionality using the browser.

Conclusion

In this post, I have given you an overview of what FMV Stack is, why you should use it, and how to build a web app with it. I hope you have found this post useful.

original: https://pythonpat.com/article/what-is-fmv-stack

Pagination with Flask and Jinja2

Graham Patrick — Tue, 30 Jan 2024 14:23:20 +0000

Have you ever wondered how to display a large amount of data on your web pages without overwhelming your users? If so, you might want to learn about pagination.

Pagination is a way of breaking down your data into smaller pieces and showing them on separate pages. This way, your users can easily navigate through your data and find what they are looking for. In this article, I will show you how to implement pagination in Python using Flask and Jinja2.

Flask is a lightweight web framework that lets you create web applications with minimal code. Jinja2 is a powerful template engine that lets you generate HTML from your data using a simple syntax. Together, they make pagination a breeze. Let's get started!

Let's see how we can build a Blog model and use pagination to display the data in an html template.

# app.py
from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blogs.db' # change this to your database URI
db = SQLAlchemy(app)

class Blog(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)

@app.route('/blogs')
@app.route('/blogs/<int:page>')
def blogs(page=1):
    per_page = 5 # change this to the number of blogs you want to display per page
    blogs = Blog.query.paginate(page, per_page, error_out=False) # get the pagination object
    return render_template('blogs.html', blogs=blogs) # pass the pagination object to the template

Yes, that’s right. To add the pagination links in the Jinja template, we can use the Pagination object that we passed from the Flask view function. The Pagination object has some useful attributes and methods that we can use to create the links, such as:

has_prev and has_next: These are boolean values that indicate if there is a previous or next page.

prev_num and next_num: These are the page numbers for the previous and next page, if they exist.

iter_pages(): This is a method that returns an iterator of all the page numbers, which we can use to create links to each page.

We can use these features in combination with the url_for function, which generates the URL for a given view function with optional arguments, to create the pagination links in our template. For example, we can write something like this:

<!-- blogs.html -->
<html>
<head>
    <title>Blogs</title>
</head>
<body>
    <h1>Blogs</h1>
    <ul>
        {% for blog in blogs.items %} <!-- loop through the items for the current page -->
        <li>
            <h2>{{ blog.title }}</h2>
            <p>{{ blog.content }}</p>
        </li>
        {% endfor %}
    </ul>
    <ul>
        <!-- previous page -->
        {% if blogs.has_prev %}
        <li>
            <a href="{{ url_for('blogs', page=blogs.prev_num) }}">Previous</a>
        </li>
        {% endif %}
        <!-- all page numbers -->
        {% for page_num in blogs.iter_pages() %}
        {% if page_num %}
        {% if page_num != blogs.page %}
        <li>
            <a href="{{ url_for('blogs', page=page_num) }}">{{ page_num }}</a>
        </li>
        {% else %}
        <li class="active">
            <a href="#">{{ page_num }}</a>
        </li>
        {% endif %}
        {% else %}
        <li>
            <span class="ellipsis">…</span>
        </li>
        {% endif %}
        {% endfor %}
        <!-- next page -->
        {% if blogs.has_next %}
        <li>
            <a href="{{ url_for('blogs', page=blogs.next_num) }}">Next</a>
        </li>
        {% endif %}
    </ul>
</body>
</html>

As you can see from the code and the output, we have successfully created a working template that displays our data in a paginated manner. We have also defined a nice model that represents our data in the database and allows us to query it easily. In addition, we have added some nice features to our templates, such as page numbers and previous and next buttons, that enable our users to navigate through our data and find what they are looking for.

And that's it! You have just learned how to create a working pagination for your data sets using Flask and Jinja2. 🎉 Isn't that awesome? 😎 Pagination is a great way to improve the user experience and performance of your web applications. 🚀 You can now display your data in a neat and organized way, and let your users navigate through it with ease. 🙌 I hope you enjoyed this tutorial and learned something new. 😊

Original post: https://pythonpat.com/article/pagination-with-flask-and-jinja2

How to Install and Use SQLAlchemy in Flask

Graham Patrick — Thu, 25 Jan 2024 16:35:16 +0000

Flask is a popular web framework for Python that allows you to create web applications quickly and easily. However, Flask does not provide any built-in support for working with databases, which are essential for storing and retrieving data for your web applications. This is where SQLAlchemy comes in handy.

SQLAlchemy is a powerful and flexible library that provides an object-relational mapper (ORM) for Python. An ORM is a tool that allows you to interact with databases using Python objects and classes, instead of writing raw SQL queries. SQLAlchemy supports many database engines, such as SQLite, PostgreSQL, MySQL, Oracle, and more.

In this blog post, you will learn how to install and use SQLAlchemy in Flask, and how to perform some common database operations, such as creating tables, inserting data, querying data, updating data, and deleting data. You will also learn how to use Flask-SQLAlchemy, an extension that simplifies using SQLAlchemy with Flask.

Installing SQLAlchemy and Flask-SQLAlchemy
To use SQLAlchemy in Flask, you need to install two packages: SQLAlchemy and Flask-SQLAlchemy. SQLAlchemy is the core library that provides the ORM functionality, and Flask-SQLAlchemy is a wrapper that integrates SQLAlchemy with Flask and adds some useful features and helpers.

You can install both packages using pip, a Python package manager. To install or update the latest version of both packages, run the following command in your terminal:

$ pip install -U SQLAlchemy Flask-SQLAlchemy

Alternatively, you can specify the packages and their versions in a requirements.txt file, and then run pip install -r requirements.txt to install them.

Configuring the Extension
The next step is to configure the Flask-SQLAlchemy extension in your Flask application. The only required configuration is the SQLALCHEMY_DATABASE_URI key, which is a connection string that tells SQLAlchemy what database engine and database name to use. You can also set some optional configuration keys, such as SQLALCHEMY_TRACK_MODIFICATIONS, which controls whether SQLAlchemy should track changes to the objects in the session.

To configure the extension, you need to create a Flask application object, load the configuration, and then initialize the Flask-SQLAlchemy extension object with the application. For example, the following code creates a Flask application, configures a SQLite database in the app’s instance folder, and initializes the extension:

from flask import Flask
from flask_sqlalchemy import SQLAlchemy

# create the extension
db = SQLAlchemy()

# create the app
app = Flask(__name__)

# configure the SQLite database, relative to the app instance folder
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///project.db"

# initialize the app with the extension
db.init_app(app)

The db object gives you access to the db.Model class to define models, and the db.session to execute queries. You can also access the names in sqlalchemy and sqlalchemy.orm for convenience, such as db.Column, db.Integer, db.String, etc.

Defining Models
To define a model class, you need to subclass db.Model and define the attributes and columns of the model. Each model class corresponds to a table in the database, and each attribute corresponds to a column in the table. You can use the db.Column class to specify the type, constraints, and options of each column. For example, the following code defines a User model class with three columns: id, username, and email:

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String, unique=True, nullable=False)
    email = db.Column(db.String)

The model class will automatically generate a table name by converting the CamelCase class name to snake_case. In this case, the table name “user” will be assigned to the User model. You can also specify a custom table name by setting the tablename attribute in the model class.

Creating the Tables
After defining the model classes, you need to create the tables in the database. You can use the db.create_all() method to create all the tables defined by the models. This method requires an application context, which is a Flask object that contains information about the current request and the current app. Since you are not in a request at this point, you need to create an application context manually using the app.app_context() context manager. For example, the following code creates the tables for the User model:

with app.app_context():
    db.create_all()

You can also use the db.drop_all() method to drop all the tables defined by the models, if you need to reset the database.

Performing Database Operations
Once you have created the tables, you can perform various database operations, such as inserting, querying, updating, and deleting data. You can use the db.session object to interact with the database, which represents a collection of objects that are in the scope of a single database transaction. You can use the db.session.add() method to add a new object to the session, the db.session.commit() method to commit the changes to the database, and the db.session.rollback() method to rollback the changes in case of an error.

Inserting Data
To insert a new record into the database, you need to create an instance of the model class, and then add it to the session and commit the changes. For example, the following code creates and inserts a new User object into the database:


# create a new User object
user = User(username="example", email="example@example.com")

# add the object to the session
db.session.add(user)

# commit the changes
db.session.commit()

You can also add multiple objects to the session at once using the db.session.add_all() method, which takes a list of objects as an argument.

Querying Data
To query data from the database, you can use the db.session.query() method, which returns a Query object that allows you to filter, order, group, and slice the results. You can also use the model class itself as a shortcut to query all the records of that model. For example, the following code queries all the User objects from the database:


# query all the User objects
users = db.session.query(User).all()

# or use the model class as a shortcut
users = User.query.all()

You can use various methods and operators on the Query object to refine the results, such as filter(), filter_by(), order_by(), limit(), offset(), count(), first(), get(), etc. For example, the following code queries the User object with the username “example”:


# query the User object with the username "example"
user = db.session.query(User).filter(User.username == "example").first()

# or use the filter_by() method as a shortcut
user = User.query.filter_by(username="example").first()

You can also use the db.session.execute() method to execute raw SQL statements, if you need more control or flexibility over the queries. For example, the following code executes a SQL statement to select all the users from the user table:


# execute a raw SQL statement
result = db.session.execute("SELECT * FROM user")

# iterate over the result
for row in result:
    print(row)

Updating Data
To update an existing record in the database, you need to query the object from the database, modify its attributes, and then commit the changes to the session. For example, the following code updates the email of the User object with the username “example”:


# query the User object with the username "example"
user = User.query.filter_by(username="example").first()

# update the email attribute
user.email = "newemail@example.com"

# commit the changes
db.session.commit()

You can also use the db.session.query().update() method to update multiple records at once, without loading them into memory. This method takes a dictionary of attribute-value pairs as an argument, and returns the number of rows affected by the update. For example, the following code updates the email of all the User objects to “test@example.com”:


# update the email of all the User objects
rows = db.session.query(User).update({"email": "test@example.com"})

# commit the changes
db.session.commit()

# print the number of rows affected
print(rows)

Deleting Data
To delete an existing record from the database, you need to query the object from the database, and then delete it from the session and commit the changes. For example, the following code deletes the User object with the username “example” from the database:


# query the User object with the username "example"
user = User.query.filter_by(username="example").first()

# delete the object from the session
db.session.delete(user)

# commit the changes
db.session.commit()

You can also use the db.session.query().delete() method to delete multiple records at once, without loading them into memory. This method returns the number of rows affected by the delete. For example, the following code deletes all the User objects from the database:


# delete all the User objects
rows = db.session.query(User).delete()

# commit the changes
db.session.commit()

# print the number of rows affected
print(rows)

Conclusion
In this blog post, you learned how to install and use SQLAlchemy in Flask, and how to perform some common database operations, such as creating tables, inserting data, querying data, updating data, and deleting data. You also learned how to use Flask-SQLAlchemy, an extension that simplifies using SQLAlchemy with Flask and adds some useful features and helpers.

SQLAlchemy is a powerful and flexible library that provides an ORM for Python, allowing you to interact with databases using Python objects

How to Build an Alexa Clone with Python and OpenAI

Graham Patrick — Tue, 23 Jan 2024 10:21:36 +0000

In this blog post, I will show you how to build a simple voice assistant app with Python and OpenAI. The app is called Peppa, and it is inspired by Pepper Potts from Iron Man. Peppa can accept voice commands from the user and respond with voice output. Peppa can also connect to OpenAI and use its powerful natural language processing capabilities to handle complex requests.

What You Will Need
To follow along with this tutorial, you will need the following:

A computer with Python 3 installed. You can download Python 3 from this source.

A microphone and speakers or headphones to interact with the app.
An OpenAI API key. You can request access to OpenAI from this source.

The following Python modules: ChatterBot, gtts, playsound, speech_recognition, and openai. You can install them with pip by running the following command in the terminal:

pip install chatterbot gtts playsound speech_recognition openai

How the App Works
The app works as follows:

The app greets the user with voice output and asks for their name.
The app gets the user’s name with voice input and greets them with voice output and name.
The app asks the user if they need to hear its voice output and gets the user’s preference with voice input.
The app asks the user what they need help with and gets the user’s request with voice input.
The app processes the user’s request and responds with voice output.
The app uses the following modules for different purposes:

ChatterBot: This module is used to create a chatbot object that can handle simple conversational requests. The chatbot uses logic adapters to generate responses based on the user’s input. In this case, we use the BestMatch and TimeLogicAdapter logic adapters to handle general and time-related requests.

gtts: This module is used to convert text to speech using Google Text-to-Speech. This module allows us to generate voice output for the app.

playsound: This module is used to play sound files using the default audio player. This module allows us to play the voice output generated by gtts.

speech_recognition: This module is used to recognize speech from audio using Google Speech Recognition. This module allows us to get voice input from the user.

openai: This module is used to interact with the OpenAI API. This module allows us to use the natural language processing capabilities of OpenAI to handle complex requests.
The Code Explained

Now that we have an overview of how the app works and what modules we need, let’s look at the code in detail. The code is divided into several sections, each with a comment explaining its purpose.

Importing the required modules
The first section of the code imports the modules that we need for the app. We also fix a compatibility issue with the collections module by assigning the Hashable attribute to the collections.abc.Hashable class.

# Importing the required modules
from chatterbot import ChatBot
import gtts
from playsound import playsound
import collections.abc
import speech_recognition as sr
import openai

# Fixing a compatibility issue with collections module
collections.Hashable = collections.abc.Hashable

Creating a speech recognizer object

The next section of the code creates a speech recognizer object that we will use to get voice input from the user. We assign the object to the variable r.

# Creating a speech recognizer object
r = sr.Recognizer()

Creating a chatbot object with logic adapters

The next section of the code creates a chatbot object that we will use to handle simple conversational requests. We assign the object to the variable bot. We also specify the storage adapter, the database URI, and the logic adapters for the chatbot. The storage adapter is used to store the chatbot’s data in a SQLite database. The database URI is the path to the database file. The logic adapters are used to generate responses based on the user’s input. We use the BestMatch and TimeLogicAdapter logic adapters to handle general and time-related requests.

# Creating a chatbot object with logic adapters
bot = ChatBot(
    "Pepper",
    storage_adapter="chatterbot.storage.SQLStorageAdapter",
    database_uri="sqlite:///db.sqlite3",
    logic_adapters=["chatterbot.logic.BestMatch", "chatterbot.logic.TimeLogicAdapter"],
)

The next section of the code sets the OpenAI API key that we will use to connect to the OpenAI API and use its natural language processing capabilities. We assign the API key to the variable api_key and set it as the openai.api_key attribute.

# Setting the OpenAI API key
api_key = ""
openai.api_key = api_key

Printing the app name in ASCII art

The next section of the code prints the app name in ASCII art to make it more attractive and fun. We use a triple-quoted string to store the ASCII art and print it with the print function.

# Printing the app name in ASCII art
print(r"""\
              _          _            _          _          _            
        /\ \       /\ \         /\ \       /\ \       / /\          
       /  \ \     /  \ \       /  \ \     /  \ \     / /  \         
      / /\ \ \   / /\ \ \     / /\ \ \   / /\ \ \   / / /\ \        
     / / /\ \_\ / / /\ \_\   / / /\ \_\ / / /\ \_\ / / /\ \ \       
    / / /_/ / // /_/_ \/_/  / / /_/ / // / /_/ / // / /  \ \ \      
   / / /__\/ // /____/\    / / /__\/ // / /__\/ // / /___/ /\ \     
  / / /_____// /\____\/   / / /_____// / /_____// / /_____/ /\ \    
 / / /      / / /______  / / /      / / /      / /_________/\ \ \   
/ / /      / / /_______\/ / /      / / /      / / /_       __\ \_\  
\/_/       \/__________/\/_/       \/_/       \_\___\     /____/_/  

      """)

Greeting the user with voice output and asking for their name

The next section of the code greets the user with voice output and asks for their name. We use the gtts module to convert text to speech and save it as a sound file. We use the playsound module to play the sound file using the default audio player.

# Greeting the user with voice output and asking for their name
tts = gtts.gTTS("Hello, My name is Peppa! And who might you be? ")
tts.save("greeting.mp3")
playsound("greeting.mp3")

Getting the user’s name with voice input and greeting them with voice output and name

The next section of the code gets the user’s name with voice input and greets them with voice output and name. We use the speech_recognition module to recognize speech from audio using Google Speech Recognition. We use the microphone as the source for input and adjust the noise level based on the surrounding noise. We listen for the user’s input and recognize it with Google. We print the recognized input and use it to personalize the greeting.

# Getting the user's name with voice input and greeting them with voice output and name
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    name = r.recognize_google(audio)
    print("I just heard ", name)

# Greeting the user with voice and name
greeting = "Hello! " + name
tts = gtts.gTTS(greeting)
tts.save("personal.mp3")
playsound("personal.mp3")

Asking the user if they need voice output and getting the user’s preference with voice input

The next section of the code asks the user if they need voice output and gets the user’s preference with voice input. We use the same technique as before to convert text to speech, play sound files, and recognize speech from audio.

# Asking the user if they need voice output
tts = gtts.gTTS("Do you need to hear my voice? Yes or no?")
tts.save("speech.mp3")
playsound("speech.mp3")

# Getting the user's preference with voice input
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    speech = r.recognize_google(audio)
    print("I just heard ", speech)

Asking the user what they need help with and getting the user’s request with voice input

The next section of the code asks the user what they need help with and gets the user’s request with voice input. We use the same technique as before to convert text to speech, play sound files, and recognize speech from audio. We also print the user’s request for confirmation.

# Asking the user what they need help with
if speech == "yes":
    tts = gtts.gTTS("and what is it I can help you with " + name + " ?")
    tts.save("text.mp3")
    playsound("text.mp3")
print("What is it I can help you with today " + name + " ?")

# Getting the user's request with voice input
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    request = r.recognize_google(audio)
    print("I just heard ", request)

Starting a loop to handle the user’s requests

The final section of the code starts a loop to handle the user’s requests and respond with voice output. We use a while loop to keep the app running until the user decides to quit. We use an if-elif-else statement to check the user’s request and generate a response accordingly. We use the following logic to handle different types of requests:

If the user’s request is “quit” or “exit”, we break the loop and end the app.
If the user’s request is “openai”, we use the openai module to connect to the OpenAI API and use its natural language processing capabilities to handle complex requests. We use the openai.Completion.create method to create a completion object that contains the response from the OpenAI API. We use the text attribute of the completion object to get the response as a string. We use the gtts module to convert the response to speech and play it with the playsound module.
If the user’s request is anything else, we use the chatterbot module to handle simple conversational requests. We use the get_response method of the chatbot object to get a response based on the user’s input. We use the gtts module to convert the response to speech and play it with the playsound module.

# Starting a loop to handle the user's requests and respond with voice output
while True:
    # Getting the user's request with voice input
    with sr.Microphone() as source:
        # Adjusting the noise level
        r.adjust_for_ambient_noise(source, duration=0.2)
        # Listening for the user's input
        audio = r.listen(source)
        # Recognizing the user's input with Google
        request = r.recognize_google(audio)
        print("I just heard ", request)

    # Checking the user's request and generating a response accordingly
    if request == "quit" or request == "exit":
        # Breaking the loop and ending the app
        break
    elif request == "openai":
        # Using the OpenAI API to handle complex requests
        completion = openai.Completion.create(
            engine="davinci",
            prompt=request,
            max_tokens=150,
            temperature=0.9,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0.6,
            stop=["\n"]
        )
        # Getting the response from the OpenAI API
        response = completion["choices"][0]["text"]
        # Converting the response to speech and playing it
        tts = gtts.gTTS(response)
        tts.save("response.mp3")
        playsound("response.mp3")
    else:
        # Using the chatbot to handle simple conversational requests
        response = bot.get_response(request)
        # Converting the response to speech and playing it
        tts = gtts.gTTS(str(response))
        tts.save("response.mp3")
        playsound("response.mp3")

The Result
That’s it! We have completed the code for our voice assistant app. We can run the app by running the following command in the terminal:

python app.py

This will start the app and greet us with voice output. We can then interact with the app using voice input and get voice output. We can ask the app anything we want, such as the time, the weather, or a joke. We can also use the keyword “openai” to access the OpenAI API and ask more complex questions, such as the meaning of life,

How to Build an Alexa Clone with Python and OpenAI

Graham Patrick — Tue, 23 Jan 2024 10:21:36 +0000

What You Will Need
To follow along with this tutorial, you will need the following:

A computer with Python 3 installed. You can download Python 3 from this source.

A microphone and speakers or headphones to interact with the app.
An OpenAI API key. You can request access to OpenAI from this source.

The following Python modules: ChatterBot, gtts, playsound, speech_recognition, and openai. You can install them with pip by running the following command in the terminal:

pip install chatterbot gtts playsound speech_recognition openai

How the App Works
The app works as follows:

gtts: This module is used to convert text to speech using Google Text-to-Speech. This module allows us to generate voice output for the app.

playsound: This module is used to play sound files using the default audio player. This module allows us to play the voice output generated by gtts.

speech_recognition: This module is used to recognize speech from audio using Google Speech Recognition. This module allows us to get voice input from the user.

openai: This module is used to interact with the OpenAI API. This module allows us to use the natural language processing capabilities of OpenAI to handle complex requests.
The Code Explained

Now that we have an overview of how the app works and what modules we need, let’s look at the code in detail. The code is divided into several sections, each with a comment explaining its purpose.

# Importing the required modules
from chatterbot import ChatBot
import gtts
from playsound import playsound
import collections.abc
import speech_recognition as sr
import openai

# Fixing a compatibility issue with collections module
collections.Hashable = collections.abc.Hashable

Creating a speech recognizer object

The next section of the code creates a speech recognizer object that we will use to get voice input from the user. We assign the object to the variable r.

# Creating a speech recognizer object
r = sr.Recognizer()

Creating a chatbot object with logic adapters

# Creating a chatbot object with logic adapters
bot = ChatBot(
    "Pepper",
    storage_adapter="chatterbot.storage.SQLStorageAdapter",
    database_uri="sqlite:///db.sqlite3",
    logic_adapters=["chatterbot.logic.BestMatch", "chatterbot.logic.TimeLogicAdapter"],
)

# Setting the OpenAI API key
api_key = ""
openai.api_key = api_key

Printing the app name in ASCII art

The next section of the code prints the app name in ASCII art to make it more attractive and fun. We use a triple-quoted string to store the ASCII art and print it with the print function.

# Printing the app name in ASCII art
print(r"""\
              _          _            _          _          _            
        /\ \       /\ \         /\ \       /\ \       / /\          
       /  \ \     /  \ \       /  \ \     /  \ \     / /  \         
      / /\ \ \   / /\ \ \     / /\ \ \   / /\ \ \   / / /\ \        
     / / /\ \_\ / / /\ \_\   / / /\ \_\ / / /\ \_\ / / /\ \ \       
    / / /_/ / // /_/_ \/_/  / / /_/ / // / /_/ / // / /  \ \ \      
   / / /__\/ // /____/\    / / /__\/ // / /__\/ // / /___/ /\ \     
  / / /_____// /\____\/   / / /_____// / /_____// / /_____/ /\ \    
 / / /      / / /______  / / /      / / /      / /_________/\ \ \   
/ / /      / / /_______\/ / /      / / /      / / /_       __\ \_\  
\/_/       \/__________/\/_/       \/_/       \_\___\     /____/_/  

      """)

Greeting the user with voice output and asking for their name

# Greeting the user with voice output and asking for their name
tts = gtts.gTTS("Hello, My name is Peppa! And who might you be? ")
tts.save("greeting.mp3")
playsound("greeting.mp3")

Getting the user’s name with voice input and greeting them with voice output and name

# Getting the user's name with voice input and greeting them with voice output and name
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    name = r.recognize_google(audio)
    print("I just heard ", name)

# Greeting the user with voice and name
greeting = "Hello! " + name
tts = gtts.gTTS(greeting)
tts.save("personal.mp3")
playsound("personal.mp3")

Asking the user if they need voice output and getting the user’s preference with voice input

# Asking the user if they need voice output
tts = gtts.gTTS("Do you need to hear my voice? Yes or no?")
tts.save("speech.mp3")
playsound("speech.mp3")

# Getting the user's preference with voice input
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    speech = r.recognize_google(audio)
    print("I just heard ", speech)

Asking the user what they need help with and getting the user’s request with voice input

# Asking the user what they need help with
if speech == "yes":
    tts = gtts.gTTS("and what is it I can help you with " + name + " ?")
    tts.save("text.mp3")
    playsound("text.mp3")
print("What is it I can help you with today " + name + " ?")

# Getting the user's request with voice input
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    request = r.recognize_google(audio)
    print("I just heard ", request)

Starting a loop to handle the user’s requests

# Starting a loop to handle the user's requests and respond with voice output
while True:
    # Getting the user's request with voice input
    with sr.Microphone() as source:
        # Adjusting the noise level
        r.adjust_for_ambient_noise(source, duration=0.2)
        # Listening for the user's input
        audio = r.listen(source)
        # Recognizing the user's input with Google
        request = r.recognize_google(audio)
        print("I just heard ", request)

    # Checking the user's request and generating a response accordingly
    if request == "quit" or request == "exit":
        # Breaking the loop and ending the app
        break
    elif request == "openai":
        # Using the OpenAI API to handle complex requests
        completion = openai.Completion.create(
            engine="davinci",
            prompt=request,
            max_tokens=150,
            temperature=0.9,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0.6,
            stop=["\n"]
        )
        # Getting the response from the OpenAI API
        response = completion["choices"][0]["text"]
        # Converting the response to speech and playing it
        tts = gtts.gTTS(response)
        tts.save("response.mp3")
        playsound("response.mp3")
    else:
        # Using the chatbot to handle simple conversational requests
        response = bot.get_response(request)
        # Converting the response to speech and playing it
        tts = gtts.gTTS(str(response))
        tts.save("response.mp3")
        playsound("response.mp3")

The Result
That’s it! We have completed the code for our voice assistant app. We can run the app by running the following command in the terminal:

python app.py

How to Build an Alexa Clone with Python and OpenAI

Graham Patrick — Tue, 23 Jan 2024 10:21:36 +0000

What You Will Need
To follow along with this tutorial, you will need the following:

A computer with Python 3 installed. You can download Python 3 from this source.

A microphone and speakers or headphones to interact with the app.
An OpenAI API key. You can request access to OpenAI from this source.

The following Python modules: ChatterBot, gtts, playsound, speech_recognition, and openai. You can install them with pip by running the following command in the terminal:

pip install chatterbot gtts playsound speech_recognition openai

How the App Works
The app works as follows:

gtts: This module is used to convert text to speech using Google Text-to-Speech. This module allows us to generate voice output for the app.

playsound: This module is used to play sound files using the default audio player. This module allows us to play the voice output generated by gtts.

speech_recognition: This module is used to recognize speech from audio using Google Speech Recognition. This module allows us to get voice input from the user.

openai: This module is used to interact with the OpenAI API. This module allows us to use the natural language processing capabilities of OpenAI to handle complex requests.
The Code Explained

Now that we have an overview of how the app works and what modules we need, let’s look at the code in detail. The code is divided into several sections, each with a comment explaining its purpose.

# Importing the required modules
from chatterbot import ChatBot
import gtts
from playsound import playsound
import collections.abc
import speech_recognition as sr
import openai

# Fixing a compatibility issue with collections module
collections.Hashable = collections.abc.Hashable

Creating a speech recognizer object

The next section of the code creates a speech recognizer object that we will use to get voice input from the user. We assign the object to the variable r.

# Creating a speech recognizer object
r = sr.Recognizer()

Creating a chatbot object with logic adapters

# Creating a chatbot object with logic adapters
bot = ChatBot(
    "Pepper",
    storage_adapter="chatterbot.storage.SQLStorageAdapter",
    database_uri="sqlite:///db.sqlite3",
    logic_adapters=["chatterbot.logic.BestMatch", "chatterbot.logic.TimeLogicAdapter"],
)

# Setting the OpenAI API key
api_key = ""
openai.api_key = api_key

Printing the app name in ASCII art

The next section of the code prints the app name in ASCII art to make it more attractive and fun. We use a triple-quoted string to store the ASCII art and print it with the print function.

# Printing the app name in ASCII art
print(r"""\
              _          _            _          _          _            
        /\ \       /\ \         /\ \       /\ \       / /\          
       /  \ \     /  \ \       /  \ \     /  \ \     / /  \         
      / /\ \ \   / /\ \ \     / /\ \ \   / /\ \ \   / / /\ \        
     / / /\ \_\ / / /\ \_\   / / /\ \_\ / / /\ \_\ / / /\ \ \       
    / / /_/ / // /_/_ \/_/  / / /_/ / // / /_/ / // / /  \ \ \      
   / / /__\/ // /____/\    / / /__\/ // / /__\/ // / /___/ /\ \     
  / / /_____// /\____\/   / / /_____// / /_____// / /_____/ /\ \    
 / / /      / / /______  / / /      / / /      / /_________/\ \ \   
/ / /      / / /_______\/ / /      / / /      / / /_       __\ \_\  
\/_/       \/__________/\/_/       \/_/       \_\___\     /____/_/  

      """)

Greeting the user with voice output and asking for their name

# Greeting the user with voice output and asking for their name
tts = gtts.gTTS("Hello, My name is Peppa! And who might you be? ")
tts.save("greeting.mp3")
playsound("greeting.mp3")

Getting the user’s name with voice input and greeting them with voice output and name

# Getting the user's name with voice input and greeting them with voice output and name
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    name = r.recognize_google(audio)
    print("I just heard ", name)

# Greeting the user with voice and name
greeting = "Hello! " + name
tts = gtts.gTTS(greeting)
tts.save("personal.mp3")
playsound("personal.mp3")

Asking the user if they need voice output and getting the user’s preference with voice input

# Asking the user if they need voice output
tts = gtts.gTTS("Do you need to hear my voice? Yes or no?")
tts.save("speech.mp3")
playsound("speech.mp3")

# Getting the user's preference with voice input
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    speech = r.recognize_google(audio)
    print("I just heard ", speech)

Asking the user what they need help with and getting the user’s request with voice input

# Asking the user what they need help with
if speech == "yes":
    tts = gtts.gTTS("and what is it I can help you with " + name + " ?")
    tts.save("text.mp3")
    playsound("text.mp3")
print("What is it I can help you with today " + name + " ?")

# Getting the user's request with voice input
with sr.Microphone() as source:
    # Adjusting the noise level
    r.adjust_for_ambient_noise(source, duration=0.2)
    # Listening for the user's input
    audio = r.listen(source)
    # Recognizing the user's input with Google
    request = r.recognize_google(audio)
    print("I just heard ", request)

Starting a loop to handle the user’s requests

# Starting a loop to handle the user's requests and respond with voice output
while True:
    # Getting the user's request with voice input
    with sr.Microphone() as source:
        # Adjusting the noise level
        r.adjust_for_ambient_noise(source, duration=0.2)
        # Listening for the user's input
        audio = r.listen(source)
        # Recognizing the user's input with Google
        request = r.recognize_google(audio)
        print("I just heard ", request)

    # Checking the user's request and generating a response accordingly
    if request == "quit" or request == "exit":
        # Breaking the loop and ending the app
        break
    elif request == "openai":
        # Using the OpenAI API to handle complex requests
        completion = openai.Completion.create(
            engine="davinci",
            prompt=request,
            max_tokens=150,
            temperature=0.9,
            top_p=1,
            frequency_penalty=0,
            presence_penalty=0.6,
            stop=["\n"]
        )
        # Getting the response from the OpenAI API
        response = completion["choices"][0]["text"]
        # Converting the response to speech and playing it
        tts = gtts.gTTS(response)
        tts.save("response.mp3")
        playsound("response.mp3")
    else:
        # Using the chatbot to handle simple conversational requests
        response = bot.get_response(request)
        # Converting the response to speech and playing it
        tts = gtts.gTTS(str(response))
        tts.save("response.mp3")
        playsound("response.mp3")

The Result
That’s it! We have completed the code for our voice assistant app. We can run the app by running the following command in the terminal:

python app.py

Creating a template and a route for the welcome message

Graham Patrick — Sun, 21 Jan 2024 15:46:39 +0000

While our Flask app works, it is not very attractive or informative. Let’s make it more appealing and personalized by creating a template and a route for the welcome message. A template is a file that contains HTML code with placeholders for dynamic content. A route is a function that handles a request for a specific URL and returns a response. We can use templates and routes to render different pages for our app.

To create a template, we need to use the Jinja2 template engine that Flask integrates with. Jinja2 is a powerful and flexible template engine that allows us to write HTML code with Python expressions and control structures. To use Jinja2, we need to create a directory called templates in the current working directory and store our template files there. Flask will automatically look for templates in this directory.

Let’s create a file called index.html in the templates directory and write the following code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Flask App</title>
</head>
<body>
    <h1>Welcome to my Flask app!</h1>
    <p>This is a simple Flask app that displays a welcome message.</p>
    <p>The welcome message is: {{ message }}</p>
</body>
</html>

This code does the following:

Defines the HTML document structure and the metadata
Displays a heading and two paragraphs of text
Uses a placeholder message to insert a dynamic value that we will pass from our route
To create a route, we need to use the app.route decorator and the render_template function that Flask provides. The app.route decorator maps a URL to a function that handles the request and returns the response. The render_template function renders a template with the given context variables and returns the result as a string.

Let’s modify our app.py file and write the following code:

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def index():
    message = "Hello, world!"
    return render_template("index.html", message=message)

This code does the following:

Imports the render_template function from the flask module
Defines a route for the root URL (“/”) using the app.route decorator
Defines a function called index that assigns a string “Hello, world!” to the message variable and passes it to the render_template function along with the name of the template file

To see the result of our changes, we need to restart the Flask development server by pressing Ctrl+C in the terminal and running the following command again:

flask run

This will restart the server and display the URL where we can access our app. If we open this URL in a web browser, we should see our new welcome page:

As you can see, our Flask app now displays a more attractive and personalized welcome message. 🙌

Creating the Flask app and running it locally

Graham Patrick — Fri, 19 Jan 2024 11:57:29 +0000

Now that we have installed Flask and created a virtual environment, we can start working on our Flask app. A Flask app is a Python object that represents the web application. To create a Flask app, we need to import the Flask class from the flask module and pass the name of the current module as an argument. This will help Flask locate the resources that we need for our app, such as templates and static files. We can also configure our app using various attributes and methods that the Flask class provides.

Let’s create a file called app.py in the current working directory and write the following code:

from flask import Flask

app = Flask(__name__)

@app.route("/")
def index():
    return "Hello, world!"

This code does the following:

Imports the Flask class from the flask module

Creates an instance of the Flask class and assigns it to the app variable

Defines a route for the root URL (“/”) using the app.route decorator

Defines a function called index that returns a string “Hello, world!” as the response

To run our Flask app locally, we need to set the FLASK_APP environment variable to the name of the file that contains our app. We can do this by running the following command in the terminal:

export FLASK_APP=app.py

This will tell Flask where to find our app. To start the Flask development server, we can run the following command in the terminal:

flask run

This will start the server and display the URL where we can access our app. You should see something like this:

Running on http://127.0.0.1:5000/ If we open this URL in a web browser, we should see our welcome message:

Congratulations, you have created and run your first Flask app! 🎉

Original Post: https://enceladus-software.com/post/152

Installing Flask and creating a virtual environment

Graham Patrick — Wed, 17 Jan 2024 11:43:47 +0000

Before we can start working on our Flask app, we need to install Flask and create a virtual environment. A virtual environment is a way of isolating the dependencies of our project from the rest of the system, so that we can avoid conflicts and ensure reproducibility.

To install Flask, we can use the pip package manager. Pip is a tool that allows us to install and manage Python packages from the Python Package Index (PyPI). To install Flask, we can run the following command in the terminal:

pip install flask

This will download and install Flask and its dependencies. You can check the version of Flask that you have installed by running:

flask --version

You should see something like this:

Flask 2.0.2
Python 3.9.7

To create a virtual environment, we can use the venv module that comes with Python. Venv is a tool that creates a directory that contains a copy of the Python interpreter and the packages that we need for our project. To create a virtual environment, we can run the following command in the terminal:

python -m venv venv

This will create a directory called venv in the current working directory. To activate the virtual environment, we can run the following command in the terminal:

source venv/bin/activate

This will change the prompt to indicate that we are in the virtual environment. You should see something like this:

(venv) $

Now, we can install Flask and any other packages that we need for our project in the virtual environment. To deactivate the virtual environment, we can run the following command in the terminal:

deactivate

This will return us to the normal prompt. You should see something like this:

Original Post: https://enceladus-software.com/post/149