Python Course With Building a Fintech Investment AI – Lesson 1: Start the Project

Intro

Today we will start the Python course and start building AI.

In the last episodes, we started the first steps to build a front-end and back-end for our fintech app.

Here are the links:

Golang course:

Golang course with building a fintech banking app – Lesson 1: Start the project

Golang course with building a fintech banking app – Lesson 2: Login and REST API

Angular course:

Angular Course with building a banking application with Tailwind CSS – Lesson 1: Start the project

Angular Course with building a banking application with Tailwind CSS – Lesson 2: Login form

Now is the time for something special!

We start building an Artificial Intelligence that will predict the stock prices and will tell us what the best option to invest now to get the biggest profit is.

I cannot wait to show you all of this.

In today’s episode, I will show you the first part of the “Python with AI” course, and we will set up the first part of the project.

The first part is the project installation, configuration, and database migrations.

Let’s start!

If you prefer video here is the youtube version:

Install flask and dependencies

The first step that you need to is dependencies installation.

We will need a few of them, but the most important for us is a flask.

Open terminal in your project’s directory and type:

pip install flask

Next, install SQLAlchemy:

pip install flask_sqlalchemy

The third one plugin that you need to install is Migrate:

pip install flask_migrate

And the last one is the PostgreSQL driver:

pip install psycopg2

Init git repo and create .gitignore

Okay, when our most important dependencies ready, we should initialize the git repository and specify the files that git should ignore.

Open the terminal and type:

git init

Next, create the .gitignore file in the project’s dir, and add a few paths, that we should ignore:

**/__pycache__/*
migrations/*
.vscode

Create app.py and import deps

It’s the first step when we will really start coding with Python.

We need to create a file named “app.py”, and import dependencies that we already installed.

import psycopg2
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

Export flask variable

When we finished creating the app.py file, we should export the path to our flask’s app.

After that, the flask will know what file should run as an application.

Open the terminal and type:

export FLASK_APP=app.py

Define app and configure DB connection

In the next step, we should define our flask application and create the app variable.

The second what we should do is to create code that will configure a connection with our database.

In the file named “app.py”, we should add our app declaration and connection string below the imports.

app = Flask(__name__)
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_DATABASE_URI'] = "postgresql://user:password@localhost:5432/dbname"

Add app run

In this step, we will focus on the app.run command.

That will let us start the application from the command line.

We will not use it in the first lesson, but we should add it to the next ones.

On the bottom of the app.py file, we should add app.run(debug=True) if the __name__ is equal to ‚__main__’.

if __name__ == '__main__':
    app.run(debug=True)

Create models directory

Great! Now we can move forward and focus on the models for the database.

In the first lesson, we will create the only model named “prices”, that will let us use the SQL table with the same name.

First of all, we need to create a directory named “models”, add it to your project.

Create prices.py in models directory and import DB from app

Now, when we have created a necessary directory, we can go into the file.

First, create the file named prices.py (add it in the directory called “models”).

Next, you should go into the prices.py file, and import variable named “db” from the app.

from app import db

Create a model in prices.py

This step is the biggest part of our today’s coding, and the most important.

We need to create the whole model that we will use for the migrations.

We should start by creating a class named “PriceMode”, and pass “db.Model”, as a param.

The next step is to declare a variable named “__tablename__” with value “prices”.

Below that line, we need to create columns that we will use inside our table.

After that, we should create a function named “__init__”, and assign our columns to the self.

Let’s take a look at how I did it in the example below.

class PriceModel(db.Model):
    __tablename__ = 'prices'

    id = db.Column(db.Integer, primary_key=True)
    company = db.Column(db.String())
    date = db.Column(db.String())
    openPrice = db.Column(db.Integer())
    highPrice = db.Column(db.Integer())
    lowPrice = db.Column(db.Integer())
    closePrice = db.Column(db.Integer())
    volume = db.Column(db.Integer())

    def __init__(self, company, date, openPrice, highPrice, lowPrice, closePrice, volume):
        self.company = company
        self.date = date
        self.openPrice = openPrice
        self.highPrice = highPrice
        self.lowPrice = lowPrice
        self.closePrice = closePrice
        self.volume = volume

    def __repr__(self):
        return f"<Price for {self.company} in day {self.date} is {self.closePrice}>"

Import models in app.py and add migrate

It’s the last step of coding now, and we run the code!

We should come back to the file named “app.py” and import our PriceModel.

After importing the model, we should declare a variable named “migrate”, and assing the Migrate function that we introduced before.

To the function named “Migrate”, we need to pass the app and db variables as params.

This code should be after variable named “db”, and before the last if-statement.

Let’s take a look at the example below.

from models.prices import PriceModel
migrate = Migrate(app, db)

Init DB

We are done with the code!

Now we should run it and check if everything is fine.

The first what you need to do is initialize DB by using this method in the terminal:

flask DB init

Migrate and upgrade

If all went well, you should have some __pycache__ directories and new dir named “migrations”.

If yes, you can go into the DB migrations.

The first of all what you need to do is to migrate, open the terminal, and type:

flask db migrate

After migration, you need to upgrade your with the results, open the terminal and type:

flask db upgrade

Conclusion

Congratulations!

Your first step into building investment AI is done.

Now your project is ready for the next features that we will focus on in the next lessons.

Code repository for the python course is here:

https://github.com/Duomly/python-ai-investment-fintech/tree/Python-AI-course-Lesson-1

In the next lesson, we will focus on building API and data for our AI.

Keep updated, and I cannot wait to show you the next steps of that powerful tool that we build together!

Thanks for reading,

Radek from Duomly

Twitter LinkedIn Pinterest