DEV Community: Ousseynou Diop

Python REST APIs with FastAPI, CRUD application

Ousseynou Diop — Mon, 01 Mar 2021 19:02:28 +0000

Originally posted on my blog

Introduction

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.

Why you should use FastApi for your next project?

Fast: Very high performance, on par with NodeJS and Go (thanks to Starlette and Pydantic). One of the fastest Python frameworks available.
Fast to code: Increase the speed to develop features by about 200% to 300%. *
Fewer bugs: Reduce about 40% of human (developer) induced errors. *
Intuitive: Great editor support. Completion everywhere. Less time debugging.
Easy: Designed to be easy to use and learn. Less time reading docs.
Short: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
Robust: Get production-ready code. With automatic interactive documentation.
Standards-based: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.

Project Setup

Start by creating a new folder to hold your project called "fastapi-blog":

mkdir fastapi-blog && cd fastapi-blog

Next, create and activate a virtual environment(we will use pipenv):

Learn how to use pipenv here

Install dependencies

pipenv install fastapi uvicorn

✔ Successfully created virtual environment!
Virtualenv location: /Users/rosie/.local/share/virtualenvs/fastapi-blog-FXGAPIoM
Creating a Pipfile for this project...
Installing fastapi...
Adding fastapi to Pipfile's [packages]...
✔ Installation Succeeded
Installing uvicorn...
Adding uvicorn to Pipfile's [packages]...
✔ Installation Succeeded
Pipfile.lock not found, creating...
Locking [dev-packages] dependencies...
Locking [packages] dependencies...
Building requirements...
Resolving dependencies...
✔ Success!
Updated Pipfile.lock (d74721)!
Installing dependencies from Pipfile.lock (d74721)...
  🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 0/0 — 00:00:00
To activate this project's virtualenv, run pipenv shell.
Alternatively, run a command inside the virtualenv with pipenv run

Run pipenv shell to activate your environment.

Create a new file and call it app.py we will put all codes in this file.

touch app.py

In this article we will use a Python list as a database, we will not use a real database.

Inside app.py file put this:

# app.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
  return {"home": "Home page"}

Open your terminal then run the server

$ uvicorn app:app

INFO:     Started server process [19004]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)

The first app is the name of the file and the second one is the name of our application app = FirstAPI.

Head up at http://127.0.0.1:8000

Learn more about uvicorn here

Let's create our fake database to store posts.

# app.py
from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional, Text
from datetime import datetime

app = FastAPI()

postdb = []

# post model
class Post(BaseModel):
    id: int
    title: str
    author: str
    content: Text
    created_at: datetime = datetime.now()
    published_at: datetime
    published: Optional[bool] = False

@app.get("/")
def read_root():
  return {"home": "Home page"}

Here we create a simple Python class with type annotations using Pydantic and Python types module.

For every blog post we store:

- the title
- the author
- the content
- the date we created it
- the date we published it
- and the status of the post

We use equal symbol(=) to add a default value.

Now, create a new route to view all posts.

# app.py
...
@app.get("/blog")
def get_posts():
    return postdb

Restart your server then open http://127.0.0.1:8000 you will see an empty list [].

Let's add our first post.

...
@app.post("/blog")
def add_post(post: Post):
    postdb.append(post.dict())
    return postdb[-1]

One of the things I really love about FastAPI is the auto-generated docs.

Head up at http://localhost:8000/docs.

Let's create our first post.
Click on Try it out then put this:

{
  "id": 1,
  "title": "Getting started with Django",
  "author": "Ousseynou DIOP",
  "content": "Hello Django",
  "created_at": "2021-03-01T18:17:45.194020",
  "published_at": "2021-03-01T18:17:58.887Z",
  "published": true
}

Create more posts then go to http://localhost:8000/blog

Let's get a single post by its ID.

# app.py
...
@app.get("/blog/{post_id}")
def get_post(post_id: int):
    post = post_id - 1
    return postdb[post]

The last two pieces of the CRUD are Update and Delete.

Let's begin by updating a post.

# app.py
...
@app.post("/blog/{post_id}")
def update_post(post_id: int, post: Post):
    postdb[post_id] = post
    return {"message": "Post has been updated succesfully"}

Add now you can update a post easily.

To be able to delete a post, you need to add this.

# app.py
...
@app.delete("/blog/{post_id}")
def delete_post(post_id: int):
    postdb.pop(post_id-1)
    return {"message": "Post has been deleted succesfully"}

Wrap up

In this article, we've learned the basic building blocks of FastAPI by creating a simple CRUD application.
Let me know if you want to learn how to integrate a database with FastAPI.

See you in the next tutorial.

How to become more productive using Makefile

Ousseynou Diop — Sat, 27 Jun 2020 06:59:13 +0000

Originally posted on my blog

Introduction

You want to become more productive, automate your workflow, there are many tools to help you achieve your goal.

make gives you the flexibility to run and compile a program from source.
In this guide, we will use it to automate our development workflow.
Note: I will use Django as an example, but the technics are applicable to other technologies.
In this guide, I will use Makefile to automate many things in Django like database migration, superuser, deployment, and more.
At the end of the guide, you'll be more productive in your development.
Before you continue, ensure that make is installed in your system.

Installation

In Order to use make we need two(2) things one(1) we need to install it in our system and finally we need to create a file called Makefile.

To install make in your system you can follow these links :
OSX
Windows

Basic examples

To explore make let's begin with this simple program, go to any directory, and create a Makefile.
Note: Don't give it an extension.

$ mkdir test_make && cd test_make
$ touch Makefile

Open the file with your text editor and put this

say_hello:
        echo "Hello world"

run the file by typing make inside the directory test_make

$ make

What is the output?
Here is what I get.

echo "Hello world"
Hello world

Django integration

If you're a Django developer, you know how tedious is to repeat again and again these commands :

python manage.py runserver
python manage.py makemigrations
python manage.py migrate
...

Let's automate them with make

Clone the example project here and follow the README guide.

git clone https://github.com/xarala221/consume-restfull-api-with-django && cd consume-restfull-api-with-django

Run the application to ensure that everything is working fine.

python manage.py migrate
python manage.py runserver

Open your browser and go to http://localhost:8000.

Inside the project, folder created a file called Makefile and add these lines.

touch Makefile

The final file will look like this

SHELL := /bin/bash

help:
    @$(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'

install:
    pipenv install

activate:
    pipenv shell

run:
    python manage.py runserver

migration:
    python manage.py makemigrations

migrate:
    python manage.py migrate

superuser:
    python manage.py createsuperuser

heroku:
    git push heroku master

deploy:
    docker-compose build
    docker-compose up -d

down:
    docker-compose down

you'll be more productive with these tips.

Conclusion

Become more productive and make things done is very important, in this guide you've learned how to automate your workflow by using make.

What do you think about this? Let us know in the comment section.

Django class-based views with pagination

Ousseynou Diop — Mon, 04 May 2020 11:56:53 +0000

Originally posted on my blog

Introduction

The final project, I am using a phonebook application – Github repo

Applications grow in terms of complexity and we will end up repeating certain functions or patterns again and again.

Django tries to take away some of that monotonous at the model and template layers, but Web developers also experience this boredom at the view level.

Built-in class-based generic views

Django’s generic views were developed to ease that pain. They take certain common idioms and patterns found in view development and abstract them so that you can quickly write common views of data without having to write too much code.

We can recognize certain common tasks, like displaying a list of objects and write code that displays a list of any object. Then the model in question can be passed as an extra argument to the URLconf.

Django ships with generic views to do the following:

Display list and detail pages for a single object. If we were creating an application to manage conferences then a TalkListView and a RegisteredUserListView would be examples of list views. A single talk page is an example of what we call a « detail » view.
Present date-based objects in year/month/day archive pages, associated detail, and « latest » pages.
Allow users to create, update, and delete objects – with or without authorization.

Taken together, these views provide easy interfaces to perform the most common tasks developers encounter.

Generic views of objects

TemplateView certainly is useful, but Django’s generic views really shine when it comes to presenting views of your database content. Because it’s such a common task, Django comes with a handful of built-in generic views that make generating list and detail views of objects incredibly easy.

Let’s start by looking at some examples of showing a list of objects or an individual object.

Here is our models:

# models.py
from django.db import models
from django.contrib.auth.models import User

# Create your models here.


class Contact(models.Model):
    first_name = models.CharField(max_length=150)
    last_name = models.CharField(max_length=150)
    phone = models.CharField(max_length=150)
    email = models.CharField(max_length=150, blank=True)
    created_by = models.ForeignKey(User, on_delete=models.SET_NULL, null=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.phone

Here are our function-based views, we'll change it later

# views.py
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, get_object_or_404, redirect
from .models import Contact


# Contact list


def contact_list(request):
    user = request.user
    contacts = Contact.objects.filter(created_by=None)
    if user.is_authenticated:
        contacts = Contact.objects.filter(created_by=user)
    return render(request, "contact/contact_list.html", {"contacts": contacts})

You see that these views do one thing display a list of Phonebook

To change this into a class-based views, add this

# views.py
...
from django.views.generic import ListView


# Contact list

class ContactList(ListView):
    model = Contact
...

You don't need to change the template name.
To display the data we need to loop throught a viraibale called object_list.

<!-- contact-list.html -->
...
<div class="row">
  <div class="col-md-6 m-auto">
    <div class="card card-body">
      {% if object_list %}
      <ul class="list-group list-group-flush">
        {% for contact in object_list %}
        <li class="list-group-item">
          <a href="{% url 'details' contact.id %}"> {{ contact.email }}</a>
        </li>
        {% endfor %}
      </ul>
      {% else %}
      <p>No contact</p>
      {% endif %}
    </div>
  </div>
</div>

Making « friendly » template contexts

Instead to use the variable object_list we can use a friendly name contacts.
The context_object_name attribute on a generic view specifies the context variable to use:

# views.py
class ContactList(ListView):
    model = Contact
    context_object_name = "contacts"

<!-- contact-list.html -->
...
<div class="row">
  <div class="col-md-6 m-auto">
    <div class="card card-body">
      {% if contacts %}
      <ul class="list-group list-group-flush">
        {% for contact in contacts %}
        <li class="list-group-item">
          <a href="{% url 'details' contact.id %}"> {{ contact.email }}</a>
        </li>
        {% endfor %}
      </ul>
      {% else %}
      <p>No contact</p>
      {% endif %}
    </div>
  </div>
</div>

Providing a useful context_object_name is always a good idea. Your coworkers who design templates will thank you.

Filtering

Another common need is filtering, if we wanted, we could use self.request.user to filter using the current user, or other more complex logic.

# views.py
...
class ContactList(ListView):
    context_object_name = "contacts"

    def get_queryset(self):
        user = self.request.user
        if user.is_authenticated:
            return Contact.objects.filter(created_by=self.request.user)
        return Contact.objects.filter(created_by=None)
...

Adding pagination

For some performance reason, we need to paginate our app, that will make it load faster.
Fortunately, Django comes with built-in pagination classes for managing paginating data of your application.

# views.py
...
class ContactList(ListView):
    context_object_name = "contacts"
    paginate_by = 4 # add this

    def get_queryset(self):
        user = self.request.user
        if user.is_authenticated:
            return Contact.objects.filter(created_by=self.request.user)
        return Contact.objects.filter(created_by=None)
...

Our template

<!-- contact-list.html -->
...
<div class="row">
  <div class="col-md-6 m-auto">
    <div class="card card-body">
      {% if contacts %}
      <ul class="list-group list-group-flush">
        {% for contact in contacts %}
        <li class="list-group-item">
          <a href="{% url 'details' contact.id %}"> {{ contact.email }}</a>
        </li>
        {% endfor %}
      </ul>
      {% else %}
      <p>No contact</p>
      {% endif %}
    </div>
    <nav aria-label="Page navigation example">
      {% if is_paginated %}
      <ul class="pagination">
        {% if page_obj.has_previous %}
        <li class="page-item">
          <a class="page-link" href="?page={{page_obj.previous_page_number}}"
            >&laquo;</a
          >
        </li>
        {% else %}
        <li class="page-item disabled">
          <a class="page-link" href="#">&laquo;</a>
        </li>
        {% endif %} {% for i in paginator.page_range %} {% if page_obj.number ==
        i %}
        <li class="page-item"><a class="page-link active">{{ i }}</a></li>
        {% else %}
        <li class="page-item">
          <a class="page-link" href="?page={{ i }}">{{ i }}</a>
        </li>
        {% endif %} {% endfor %} {% if page_obj.has_next %}
        <li class="page-item">
          <a href="?page={{page_obj.next_page_number}}" class="page-link"
            >&raquo;</a
          >
        </li>
        {% else %}
        <li class="page-item disabled">
          <a class="page-link">&raquo;</a>
        </li>
        {% endif %}
      </ul>
      {% endif %}
    </nav>
  </div>
</div>

Now run the server and visit http://127.0.0.1:8000/ you should see the page navigation buttons below the contacts.

python manage.py runserver

Conclusion

In this tutorial, we've learned how to work with django class-based views.
You can do more stuff with like Form submitting, we'll cover them next.

Thanks for reading, see you next.

Django testing using pytest

Ousseynou Diop — Sat, 02 May 2020 19:05:30 +0000

Originally posted on my blog

Introduction

In our previous article we've discussed writing simple tests in Django.
In this article, we'll go one step further.

Pytest helps you write better programs.

The Pytest framework makes it easy to write small tests, yet scales to support complex functional testing for applications and libraries.

Here is an example of a simple test

def inc(x):
   return x + 1


def test_answer():
   assert inc(3) == 5

Execute it, what is the result?

A great developer should test his code before the client or user interaction.
Testing is not an easy task as you may think.
Writing advanced tests is very challenging but pytest makes it a lot easier than before.

Why Pytest

You can test your Django application without using a Library but pytest offers some features that are not present in Django’s standard test mechanism: :

Detailed info on failing assert statements (no need to remember self.assert* names);
Auto-discovery of test modules and functions;
Modular fixtures for managing small or parametrized long-lived test resources;
Can run unit test (including trial) and nose test suites out of the box;
More about pytest here

Pytest vs Django unit testing Framework

Here is a basci comparaison

from django.test import TestCase


class TestHelloWorld(TestCase):
   def test_hello_world(self):
       self.assertEqual("hello world", "hello world")

Using Pytest

def test_hello_world():
   assert "hello_world" == "hello_world"

Setting Up Pytest Django

pytest-django is a plugin for pytest that provides a set of useful tools for testing Django applications and projects.

You can find the final code here

Create a new virtual environment

mkdir django_testing_using_pytest && cd django_testing_using_pytest
virtualenv venv # this command will create a virtual environment called venv

Activate our virtual environment

source /venv/bin/activate

Install Django and pytest-django

pip install django pytest-django

Create a new Django project from the terminal

django-admin startproject django_testing .

Don't forget to put the dot(.) at the end.

Create a simple django application

python manage.py startapp main_app

# settings.py
INSTALLED_APPS = [
  'django.contrib.admin',
  'django.contrib.auth',
  'django.contrib.contenttypes',
  'django.contrib.sessions',
  'django.contrib.messages',
  'django.contrib.staticfiles',
  'main_app.apps.MainAppConfig' # add this
]

Change the templates directory

# settings.py
TEMPLATES = [
  {
      'BACKEND': 'django.template.backends.django.DjangoTemplates',
      'DIRS': [os.path.join(BASE_DIR, 'templates')],  # add this
      'APP_DIRS': True,
      'OPTIONS': {
          'context_processors': [
              'django.template.context_processors.debug',
              'django.template.context_processors.request',
              'django.contrib.auth.context_processors.auth',
              'django.contrib.messages.context_processors.messages',
          ],
      },
  },
]

Run the application and make sure everything is working as expected

python manage.py runserver

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).

You have 17 unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): admin, auth, contenttypes, sessions.
Run 'python manage.py migrate' to apply them.

May 01, 2020 - 20:28:17
Django version 3.0.5, using settings 'django_testing.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Make sure DJANGO_SETTINGS_MODULE is defined.

Create a file called pytest.ini in your project root directory that contains:

touch pytest.ini

# pytest.ini
[pytest]
DJANGO_SETTINGS_MODULE = django_testing.settings
# -- recommended but optional:
python_files = tests.py test_*.py *_tests.py

Let's run our test suite

$ pytest
============================= test session starts ==============================
platform linux -- Python 3.7.5, pytest-5.4.1, py-1.8.1, pluggy-0.13.1
rootdir: /home/username/projects/username/source-code/django_testing_using_pytest, inifile: pytest.ini
plugins: django-3.9.0
collected 0 items

You may ask why run test suite instead of Django manage.py command, here is the answer :

Less boilerplate: no need to import unittest, create a subclass with methods. Just write tests as regular functions.
Manage test dependencies with fixtures.
Run tests in multiple processes for increased speed.
There are a lot of other nice plugins available for pytest.
Easy switching: Existing unittest-style tests will still work without any modifications.

See the pytest documentation for more information on pytest.

Test Discovery

The first thing that pytest provides is test discovery. Like nose, starting from the directory where it is run, it will find any Python module prefixed with test* and will attempt to run any defined unittest or function prefixed with test*. pytest explores properly defined Python packages, searching recursively through directories that include init.py modules.

Here is an example :

├── django_testing
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── main_app
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   ├── __init__.py
│   │   └── __pycache__
│   │       └── __init__.cpython-37.pyc
│   ├── models.py
│   ├── test_contact.py # checked for tests
│   ├── test_blog.py # checked for tests
│   ├── test_todo.py # checked for tests
│   └── views.py

Let's write a test for our model

# models.py
from django.db import models

class Contact(models.Model):
   first_name = models.CharField(max_length=150)
   last_name = models.CharField(max_length=150)
   phone = models.CharField(max_length=150)
   email = models.CharField(max_length=150, blank=True)
   created_at = models.DateTimeField(auto_now_add=True)

   def __str__(self):
       return self.phone

# tests.py

import pytest
from .models import Contact


@pytest.mark.django_db
def test_contact_create():
   contact = Contact.objects.create(
       first_name="John",
       last_name="Doe",
       email="john@gmail.com",
       phone="00221 70 992 33 43"
   )
   assert contact.email == "john@gmail.com"
   assert contact.phone == "00221 70 992 33 43"

Run the test

pytest
============================= test session starts =============================
platform linux -- Python 3.7.5, pytest-5.4.1, py-1.8.1, pluggy-0.13.1
django: settings: django_testing.settings (from ini)
rootdir: /home/username/projects/username/source-code/django_testing_using_pytest, inifile: pytest.ini
plugins: django-3.9.0
collected 1 item

main_app/tests.py .                                                     [100%]

============================== 1 passed in 0.27s ==============================

Our test passed.

Let's break our code and run the test again

# tests.py

import pytest
from .models import Contact


@pytest.mark.django_db
def test_contact_create():
   contact = Contact.objects.create(
       first_name="John",
       last_name="Doe",
       email="john@gmail.com",
       phone="00221 70 992 33 43"
   )
   assert contact.email == "john@hotmail.com"
   assert contact.phone == "00221 70 992 33 43"

Run the test

================================== FAILURES ===================================
_____________________________ test_contact_create _____________________________

   @pytest.mark.django_db
   def test_contact_create():
       contact = Contact.objects.create(
           first_name="John",
           last_name="Doe",
           email="john@gmail.com",
           phone="00221 70 992 33 43"
       )
>       assert contact.email == "john@hotmail.com"
E       AssertionError: assert 'john@gmail.com' == 'john@hotmail.com'
E         - john@hotmail.com
E         ?      ^^^
E         + john@gmail.com
E         ?      ^

main_app/tests.py:14: AssertionError
=========================== short test summary info ===========================
FAILED main_app/tests.py::test_contact_create - AssertionError: assert 'john...
============================== 1 failed in 0.33s ==============================

Conclusion

In this article we've how to setup Pytest with Django, you can do more stuff with Pytest it's well documented.
We'll write test coverage in our next article.

Thanks for reading, See you next.

How to consume RESTful APIs with Django - the easiest way

Ousseynou Diop — Wed, 29 Apr 2020 21:35:13 +0000

Originally posted on my blog

Introduction

A REST API defines a set of functions which developers can perform requests and receive responses via HTTP protocol such as GET, POST, PUT and DELETE

Think REST API as a web service that provides you the data you want to use in your application(mobile or front-end client).

The key components for a REST API request are:

GET — The most common option, returns some data from the API based on the given endpoint.
POST — Creates a new record and add it to the database.
PUT — Update an existing record.
DELETE — Deletes the record on the given endpoint.

In this guide, we will use JSONPlaceholder API.

The final project Here

Setting up

Create a new virtual environment

mkdir use_rest_api_with_django && cd use_rest_api_with_django
virtualenv venv

Activate our virtual environment

source /ven/bin/activate

Install Django and requests Library

pip install Django requests

Create a new Django project from the terminal

django-admin startproject consume_restful_api .

Don't forget to put the dot(.) at the end.

Create a simple Django application

python manage.py startapp main_app

# settings.py
INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'main_app.apps.MainAppConfig' # add this
]

Change the templates directory

# settings.py
TEMPLATES = [
   {
       'BACKEND': 'django.template.backends.django.DjangoTemplates',
       'DIRS': [os.path.join(BASE_DIR, 'templates')],  # add this
       'APP_DIRS': True,
       'OPTIONS': {
           'context_processors': [
               'django.template.context_processors.debug',
               'django.template.context_processors.request',
               'django.contrib.auth.context_processors.auth',
               'django.contrib.messages.context_processors.messages',
           ],
       },
   },
]

Inside the views.py file add this

# views.py
import requests
from django.shortcuts import render


def home(request):
   # get the list of todos
   response = requests.get('https://jsonplaceholder.typicode.com/todos/')
   # transfor the response to json objects
   todos = response.json()
   return render(request, "main_app/home.html", {"todos": todos})

Create the required templates

mkdir templates && mkdir templates/main_app
touch templates/base.html && touch templates/main_app/home.html

base.html

<!-- base.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>How to consume RESTful APIs with Django</title>
  </head>
  <body>
    <h2>How to consume RESTful APIs with Django</h2>

    {% block content %} {% endblock content %}
  </body>
</html>

home.html

<!-- base.html -->
{% extends "base.html" %} {% block content %}
<ul>
  {% for todo in todos %}
  <li>{{ todo.id }} - {{ todo.title }}</li>
  {% endfor %}
</ul>
{% endblock content %}

Let's add some styling with bootstrap

Change the base.html file

<!-- base.html -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      rel="stylesheet"
      href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"
      integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh"
      crossorigin="anonymous"
    />
    <title>How to consume RESTful APIs with Django</title>
  </head>
  <body>
    <h2 class="text-center">How to consume RESTful APIs with Django</h2>

    <div class="container">
      {% block content %} {% endblock content %}
    </div>
  </body>
</html>

And home.html

<!-- home.html -->
{% extends "base.html" %}

{% block content %}
<div class="col-md-6 col-auto">
  <div class="card">
    <div class="card-header">
      Todos
    </div>
    <ul class="list-group list-group-flush">
      {% for todo in data %}
      <li class="list-group-item">{{ todo.id }} - {{ todo.title }}</li>
      {% endfor %}
    </ul>
  </div>
</div>
{% endblock content %}

Conclusion

In this article, we've learned how to consume RESTful APIs with Django and Python requests Library.

Thanks for reading.

How to setup Python Virtual environment using virtualenv

Ousseynou Diop — Wed, 29 Apr 2020 11:26:01 +0000

Originally posted on my blog

Introdcution

Python applications may require some packages and modules that don’t come as part of the standard library.

This means it may not be possible for one Python installation to meet the requirements of every application.

For example, you can work on a project that requires Django 1.3 while also maintaining a project that requires Django 3.0.

The solution for this kind of problem is to create a Virtual environtment

The main purpose of using a package manager is to separate your application dependencies, which will give you the ability to use the one Framework in a different project with a different version.

Virtualenv

In this guide we will use virtualenv as described in the documentation of the library, Virtualenv is a tool to create isolated Python environments. Since Python 3.3, a subset of it has been integrated into the standard library under the venv module.

Installation

via pipx

virtualenv is a CLI tool that needs a Python interpreter to run. If you already have a Python 3.5+ interpreter the best is to use pipx to install virtualenv into an isolated environment. This has the added benefit that later you’ll be able to upgrade virtualenv without affecting other parts of the system.

pipx install virtualenv
virtualenv --help

via pip

Alternatively you can install it within the global Python interpreter itself (perhaps as a user package via the --user flag). Be cautious if you are using a python install that is managed by your operating system or another package manager. pip might not coordinate with those tools and may leave your system in an inconsistent state. Note, if you go down this path you need to ensure pip is new enough per the subsections below:

python -m pip install --user virtualenv

Check the installation

This command will give you more details about Virtualenv

python -m virtualenv --help

Create a new project using Virtualenv

Create a new folder

mkdir json_placeholder_api && cd json_placeholder_api

Create a virtual environment with Virtualenv

virtualenv json_placeholder_env

Using base prefix '/usr'
New python executable in /home/username/projects/xarala/source-code/virtualenv_setup/json_placeholder_api/json_placeholder_env/bin/python3
Also creating executable in /home/username/projects/xarala/source-code/virtualenv_setup/json_placeholder_api/json_placeholder_env/bin/python
Installing setuptools, pip, wheel...
done.

Activate the new virtual environment

source json_placeholder_env/bin/activate

(json_placeholder_env) username@...

Install requests Library
requests Library allows you to send HTTP/1.1 requests easily.

pip install requests

Collecting requests
  Using cached requests-2.23.0-py2.py3-none-any.whl (58 kB)
Collecting idna<3,>=2.5
  Using cached idna-2.9-py2.py3-none-any.whl (58 kB)
Collecting urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1
  Using cached urllib3-1.25.9-py2.py3-none-any.whl (126 kB)
Collecting chardet<4,>=3.0.2
  Using cached chardet-3.0.4-py2.py3-none-any.whl (133 kB)
Collecting certifi>=2017.4.17
  Using cached certifi-2020.4.5.1-py2.py3-none-any.whl (157 kB)
Installing collected packages: idna, urllib3, chardet, certifi, requests
Successfully installed certifi-2020.4.5.1 chardet-3.0.4 idna-2.9 requests-2.23.0 urllib3-1.25.9

Create a new file and renamed it app.py

touch app.py

We will use Json placeholder api

Add this

# app.py

import requests

api_endpoint = requests.get('https://jsonplaceholder.typicode.com/todos/')

def get_posts(endpoint):
  return endpoint.json()

result = get_posts(api_endpoint)
print(result)

Share packages

It's very important if you work with others to have a mechanism to share packages, one of the method if to use a file called requirements.txt

In your terminal

pip freeze > requirements.txt

This command will put all the dependencies into the requiremnsts.txt file.

Conclusion

As the project grow in terms of complexity, it's a good practice to have a Python virtual environment.
In this tutorial, we've learned how to set up it with Virtualenv

Thanks for reading 😍 See you next

How to Backup MySQL Databases on Ubuntu VPS Server Automatically

Ousseynou Diop — Sun, 26 Apr 2020 17:10:33 +0000

Originally posted on my blog

Introduction

Backing up your customer's data regularly is very important and you should do it. This article shows you how to backup MySQL database at regular bases.

MySQL is an open source Relational Database Management System (RDBMS) that uses Structured query Language(SQL).
MySQL is very popular and used by many companies and Websites.

Why you should backup your database

There are many reasons why you should backup your database :

Have a copy of your data
Increase the level of security

Backup database manually using mysqldump

Most developers prefer creating and downloading the database manually.

mysqldump -u username -p database_name > data-dump.sql

This command will create a file called data-dump.sql , keep it in safe location.

To restore the database

 mysql -u username -p database_name < data-dump.sql

You've done the backup and the restoration, let's make it great again 😍

Backup database automatically using automysqlbackup

AutoMySQLBackup is a program that lets you take daily, weekly and monthly backups of your MySQL databases using mysqldump. It can back up multiple databases, compress the backups, back up remote databases, and email the logs.

Features :

Email notification of backups
Backup Compression and Encryption
Configurable backup rotation
Incremental database backups

Type the following command into the terminal to install the program:

sudo apt-get install automysqlbackup

A following prompt will ask you which mail configuration you prefer. Select “internet site” if you’re going to set up email notification. If not, just select “no configuration”.

Start the program

sudo automysqlbackup

The default location for Backups is /var/lib/automysqlbackup.

You should see three directories : daily, weakly, monthly.

The configuration file for automysqlbackup is located at /etc/default/automysqlbackup.

You can Open it in your favorite editor:

sudo nano /etc/default/automysqlbackup

You can do some customization, in many cases the defaults configurations can be left intact.

Conclusion

Now You are able to sleep well at night, knowing that your customer’s data will be backed up at regular bases.

Thank you for reading 💓 see you next.

Django testing - best practices and Examples

Ousseynou Diop — Wed, 22 Apr 2020 07:51:33 +0000

Originally posted on my blog

Introduction

Django is a high level framework to build scalable web applications.
Django is used by companies like Google, Facebook, Pinterest, Nasa etc...

Code quality is very important in software engineering.
Testing is one of the best practices of a good developer, the reality is that everyone talk about it but in real word not everyone write tests 😁

We've many types of tests but in this tutorial i will cover two of them :

Unit Tests Is a level of software testing where a section(unit) of an application meets the requirements, it focus on one specific function.
Integration Tests Is a level of software testing where individual sections are combined and tested as a group, it combined multiple pieces of code and functionality.

When and Why run tests

Testing helps us structure good code, maintain large codebase and find bugs.
Well written tests make your code - easy to debug, integrate and deploy.
Well written tests save us lot of times.
Whatever you're a solo developer or you work in a team you should write tests.

Best practices

If it can break, it should be tested. This includes models, views, forms, templates, validators, and so forth. Each test should generally only test one function.
Keep it simple. You do not want to have to write tests on top of other tests.
Run tests whenever code is PULLed or PUSHed from the repo and in the staging environment before PUSHing to production.
When upgrading to a newer version of Django:
upgrade locally,
run your test suite,
fix bugs,
PUSH to the repo and staging, and then
test again in staging before shipping the code.

Learn more here

Setup

You can find the final source code here

Create a virtual environment then activate it Learn more

pipenv shell
(phonebook_rest_api-9zIZds3o) ╭─username@username-Latitude-7480

Run migrations

python manage.py migrate
Operations to perform:
 Apply all migrations: admin, auth, contact, contenttypes, sessions

Run the application

python manage.py runserver
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
April 21, 2020 - 18:37:31
Django version 3.0.2, using settings 'phonebook.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

Open your browser at http://localhost:8000/

We assure that everything is working properly.

Structure

By default all new apps in a Django project come with a tests.py file. Any test within this file that starts with _test__ will be run by Django's test runner. Make sure all test files start with _test__.

As applications grow in complexity, it's recommended to delete this initial tests.py file and replace it with an app-level tests folder that contains individual tests files for each area of functionality.

In real world application you should have something like this :

├── contact
│   ├── admin.py
│   ├── api.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   ├── 0001_initial.py
│   │   └── __init__.py
│   ├── models.py
│   ├── serializers.py
│   ├── tests # new
│   │   ├── __init__.py
│   │   ├── test_forms.py # new
│   │   ├── test_models.py # new
│   │   └── test_views.py # new
│   ├── urls.py
│   └── views.py

In this article i will keep it simple.

Before writing any tests we will create a new django app and called it pages it will contain our static pages(home and about)

python manage.py startapp pages

# Application definition

INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'rest_framework',  # add this
   'contact'  # add this
   'pages' # new
]

Update pages views.py

# pages views.py
from django.shortcuts import render
from django.views.generic import TemplateView


class HomePageView(TemplateView):
   template_name = 'pages/home.html'


class AboutPageView(TemplateView):
   template_name = 'pages/about.html'

Create urls.py inside pages

touch pages/urls.py

# pages/urls.py
from django.urls import path

from .views import HomePageView, AboutPageView

urlpatterns = [
   path('', HomePageView.as_view(), name='home'),
   path('about/', AboutPageView.as_view(), name='about'),
]

And finally update your main urls.py

from django.contrib import admin
from django.urls import path, include  # add this

urlpatterns = [
   path('admin/', admin.site.urls),
   path("", include("contact.urls")),  # add this
   path("", include("accounts.urls")),  # add this
   path("", include("pages.urls"))  # new
]

Create your templates

mkdir templates/pages
touch templates/pages/home.html
touch templates/pages/about.html

Let's add some html content

<!-- templates/pages/home.html -->
<h1>Homepage</h1>

<!-- templates/pages/about.html -->
<h1>About page</h1>

Run again your server to assure that everything is working properly.

python manage.py runserver
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
April 22, 2020 - 06:46:31
Django version 3.0.2, using settings 'phonebook.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
[22/Apr/2020 06:46:33] "GET / HTTP/1.1" 200 2268

Open your browser then navigate to the homepage urls

Simple TestCase

Now we will test our static pages without involving a database.
Let's test the homepage

# pages/tests.py

from django.http import HttpRequest
from django.test import SimpleTestCase
from django.urls import reverse

from . import views


class HomePageTests(SimpleTestCase):

   def test_home_page_status_code(self):
       response = self.client.get('/')
       self.assertEquals(response.status_code, 200)

   def test_view_url_by_name(self):
       response = self.client.get(reverse('home'))
       self.assertEquals(response.status_code, 200)

   def test_view_uses_correct_template(self):
       response = self.client.get(reverse('home'))
       self.assertEquals(response.status_code, 200)
       self.assertTemplateUsed(response, 'pages/home.html')

   def test_home_page_contains_correct_html(self):
       response = self.client.get('/')
       self.assertContains(response, '<h1>Homepage</h1>')

   def test_home_page_does_not_contain_incorrect_html(self):
       response = self.client.get('/')
       self.assertNotContains(
           response, 'Hi there! No data found.')

Now run the tests

python manage.py test
System check identified no issues (0 silenced).
.....
---------------------------------------------------------------------------
Ran 5 tests in 0.015s

OK

It's working properly

Let's do the same thing for the about page

# pages/tests.py
class AboutPageTests(SimpleTestCase):

   def test_about_page_status_code(self):
       response = self.client.get('/about/')
       self.assertEquals(response.status_code, 200)

   def test_view_url_by_name(self):
       response = self.client.get(reverse('about'))
       self.assertEquals(response.status_code, 200)

   def test_view_uses_correct_template(self):
       response = self.client.get(reverse('about'))
       self.assertEquals(response.status_code, 200)
       self.assertTemplateUsed(response, 'pages/about.html')

   def test_about_page_contains_correct_html(self):
       response = self.client.get('/about/')
       self.assertContains(response, '<h1>About page</h1>')

   def test_about_page_does_not_contain_incorrect_html(self):
       response = self.client.get('/')
       self.assertNotContains(
           response, 'Hi there! I should not be on the page.')

Then run

python manage.py test

System check identified no issues (0 silenced).
..........
---------------------------------------------------------------------------
Ran 10 tests in 0.023s

OK

This works fine

TestCase

Testcase is the most common class to use for writing test in Django it gives us the ability to mock queries to the database.

Let's test out our Contact database model

# contact/tests.py
from django.test import TestCase
from django.urls import reverse

from .models import Contact


class ContactTests(TestCase):

   def setUp(self):
       Contact.objects.create(
           first_name='Ousseynou',
           last_name="Diop",
           phone="779929900",
           email="hello@me.com"
       )

   def test_email_content(self):
       contact = Contact.objects.get(id=1)
       expected_object_name = f'{contact.email}'
       self.assertEquals(expected_object_name, 'hello@me.com')

   def test_contact_list_view(self):
       response = self.client.get(reverse('contacts'))
       self.assertEqual(response.status_code, 200)
       self.assertContains(response, 'hello@me.com')
       self.assertTemplateUsed(response, 'contact/contact_list.html')

Then run

python manage.py test

System check identified no issues (0 silenced).
..........
---------------------------------------------------------------------------
Ran 10 tests in 0.023s

OK

This works fine! let's break the code.

# contact/tests.py
from django.test import TestCase
from django.urls import reverse

from .models import Contact


class ContactTests(TestCase):

   def setUp(self):
       Contact.objects.create(
           first_name='Ousseynou',
           last_name="Diop",
           phone="779929900",
           email="hello@me.com"
       )

   def test_email_content(self):
       contact = Contact.objects.get(id=1)
       expected_object_name = f'{contact.email}'
       self.assertEquals(expected_object_name, 'hello@gmail.com') # new

   def test_contact_list_view(self):
       response = self.client.get(reverse('contacts'))
       self.assertEqual(response.status_code, 200)
       self.assertContains(response, 'hello@me.com')
       self.assertTemplateUsed(response, 'contact/contact_list.html')

Then run the test again

python manage.py test
System check identified no issues (0 silenced).
.F..........
======================================================================
FAIL: test_email_content (contact.tests.ContactTests)
---------------------------------------------------------------------------
Traceback (most recent call last):
 File "/home/username/projects/phonebook_rest_api/contact/tests.py", line 20, in test_email_content
   self.assertEquals(expected_object_name, 'hello@gmail.com')
AssertionError: 'hello@me.com' != 'hello@gmail.com'
- hello@me.com
?        ^
+ hello@gmail.com
?       + ^^^


---------------------------------------------------------------------------
Ran 12 tests in 0.030s

FAILED (failures=1)
Destroying test database for alias 'default'...

Our tests are failed.

Now you understand how tests are important in software engineering.

Conclusion

In this article we've learned how to write tests for our django project.
The next steps are to write TDD, setup CI/CD in order to maintain code quality.

Thank you for reading 😍 See you in the next article.

How to build a Todo application with Python Flask, Heroku and Tailwind CSS

Ousseynou Diop — Mon, 13 Apr 2020 20:38:54 +0000

Originally posted on my blog

Introduction

Flask is called a MicroFramework because it gives you the basic tools you need in order to build a web application in Python.
With Flask you can build any kind of Web service or backend application.
If you're beginning using Python for web development i suggest you to start with Django.

In this guide We will build a Todo application from Scratch with Tailwind A utility-first CSS framework for rapidly building custom designs.

Requirements

To follow along with me make sure you've :

python3
pip3
pipenv
Tailwind CDN

Application Setup

Create new folder and install the necessary tools.

Create a new folder

$ mkdir flask_tailwind_todo_app
$ cd flask_tailwind_todo_app/
...

Create a Virtual environment with pipenv

$ pipenv shell
...

Creating a virtualenv for this project…
Using /usr/bin/python3 (3.7.5) to create virtualenv…
⠋Already using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/username/.local/share/virtualenvs/flask_tailwind_todo_app-4wPj_lFD/bin/python3
Also creating executable in /home/username/.local/share/virtualenvs/flask_tailwind_todo_app-4wPj_lFD/bin/python
Installing setuptools, pip, wheel...
done.

Virtualenv location: /home/username/.local/share/virtualenvs/flask_tailwind_todo_app-4wPj_lFD
Creating a Pipfile for this project…
Spawning environment shell (/usr/bin/zsh). Use 'exit' to leave.
. /home/username/.local/share/virtualenvs/flask_tailwind_todo_app-4wPj_lFD/bin/activate
username@username-Latitude-7480 ~/projects/xarala/source-code/flask_tailwind_todo_app
╰─$ . /home/username/.local/share/virtualenvs/flask_tailwind_todo_app-4wPj_lFD/bin/activate
(flask_tailwind_todo_app-4wPj_lFD) username@username-Latitude-7480 ~/projects/xarala/source-code/flask_tailwind_todo_app
╰─$

This command will create a new virtual environment and activate it.

You can learn more about Pipenv in this Post

Install flask, sqlalchemy and gunicorn

$ pipenv install flask flask-sqlalchemy gunicorn

This will install Flask, Sqlalchemy and gunicorn in our virtual environment.

Create our first Flask app

Create new file inside flask_tailwind_todo_app directory

$ touch app.py

Add

from flask import Flask

app = Flask(__name__)


@app.route("/")
def home():
   return "Hello Flask"


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

Open your terminal and run

$ python app.py

You'll see something like this

* Serving Flask app "app" (lazy loading)
* Environment: production
  WARNING: This is a development server. Do not use it in a production deployment.
  Use a production WSGI server instead.
* Debug mode: on
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
* Restarting with stat
* Debugger is active!
* Debugger PIN: 278-921-051

Go to http://127.0.0.1:5000/ what is the result ?

If everything work fine you'll see Hello Flask
Let's make it great by rendering a template

Rendering Templates

from flask import Flask, render_template

app = Flask(__name__)


@app.route("/")
def home():
   return render_template("home.html")


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

If you run reload your browser you'll see an error like this jinja2.exceptions.TemplateNotFound

Let's fix it by creating our templates folder

Inside templates folder create home.html file and add this code.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Flask Todo App with Tailwind</title>
  </head>
  <body>
    <h1>Hello Flask</h1>
  </body>
</html>

Reload your browser what you see ?
Let's add some css with tailwind, in this tutorial i will use the CDN version.

Don't use the CDN if you want to have all Tailwind features.

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://unpkg.com/tailwindcss@^1.0/dist/tailwind.min.css"
      rel="stylesheet"
    />
    <title>Flask Todo App with Tailwind</title>
  </head>
  <body>
    <h1 class="text-center">Hello Flask</h1>
  </body>
</html>

We will use a template from Tailwind components here is the source code

Every website in some point or other will need some custom css files, let's add static files.

Static files

Create base.html file and move all the content of home.html into it

base.html

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <link
      href="https://unpkg.com/tailwindcss@^1.0/dist/tailwind.min.css"
      rel="stylesheet"
    />
    <link
      rel="stylesheet"
      href="{{ url_for('static', filename='css/style.css') }}"
    />
    <title>
      {% if title %}
      {{ title }}
      {% else %} Flask Todo App with Tailwind
      {% endif %}
    </title>
  </head>
  <body>
    <div
      class="h-100 w-full flex items-center justify-center bg-teal-lightest font-sans"
    >
      {% block content %}

      {% endblock content %}
    </div>
  </body>
</html>

home.html

{% extends "base.html" %} {% block content %}
<div class="bg-white rounded shadow p-6 m-4 w-full lg:w-3/4 lg:max-w-lg">
  <div class="mb-4">
    <h1 class="text-grey-darkest">Flask Todo List</h1>
    <div class="flex mt-4">
      <input
        class="shadow appearance-none border rounded w-full py-2 px-3 mr-4 text-grey-darker"
        placeholder="Add Todo"
      />
      <button
        class="flex-no-shrink p-2 border-2 rounded text-teal border-teal hover:text-white hover:bg-teal"
      >
        Add
      </button>
    </div>
  </div>
  <div>
    <div class="flex mb-4 items-center">
      <p class="w-full text-grey-darkest">
        Add another component to Tailwind Components
      </p>
      <button
        class="flex-no-shrink p-2 ml-2 border-2 rounded text-red border-red hover:text-white hover:bg-red"
      >
        Remove
      </button>
    </div>
  </div>
</div>
{% endblock content %}

Everything here is static, let's add dynamic data...

Working with database (CRUD)

We will use SQlite as the database adapter

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy  # add
from datetime import datetime  # add

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///todo.db'  # add
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False  # add
db = SQLAlchemy(app)  # add

# add


class Task(db.Model):
   id = db.Column(db.Integer, primary_key=True)
   name = db.Column(db.String(80), nullable=False)
   created_at = db.Column(db.DateTime, nullable=False,
                          default=datetime.now)

   def __repr__(self):
       return f'Todo : {self.name}'


@app.route("/")
def home():
   return render_template("home.html")


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

Let's add some data from Python interpreter(REPL)

$ python
Python 3.7.5 (default, Nov 20 2019, 09:21:52)
[GCC 9.2.1 20191008] on linux
Type "help", "copyright", "credits" or "license" for more information.

>>> from app import db, Task
>>> db.create_all()
>>> new_task = Task(name="Learn Flask")
>>> db.session.add(new_task)
>>> db.session.commit()
>>> tasks = Task.query.all()
>>> tasks
[Todo : Learn Flask]
>>>

Getting data

We added our fist todo successfully from the REPL let's display the in our template home.html

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy  # add
from datetime import datetime  # add

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///todo.db'  # add
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False  # add
db = SQLAlchemy(app)  # add

# add


class Task(db.Model):
   id = db.Column(db.Integer, primary_key=True)
   name = db.Column(db.String(80), nullable=False)
   created_at = db.Column(db.DateTime, nullable=False,
                          default=datetime.now)

   def __repr__(self):
       return f'Todo : {self.name}'


@app.route("/")
def home():
   tasks = Task.query.order_by(Task.created_at) # add
   return render_template("home.html", tasks=tasks) # add


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

Change your home.html file

{% extends "base.html" %}
{% block content %}
<div class="bg-white rounded shadow p-6 m-4 w-full lg:w-3/4 lg:max-w-lg">
  <div class="mb-4">
    <h1 class="text-grey-darkest">Flask Todo List</h1>
    <div class="flex mt-4">
      <input
        class="shadow appearance-none border rounded w-full py-2 px-3 mr-4 text-grey-darker"
        placeholder="Add Todo"
      />
      <button
        class="flex-no-shrink p-2 border-2 rounded text-teal border-teal hover:text-white hover:bg-teal bg-green-600"
      >
        Add
      </button>
    </div>
  </div>
  <div>
    {% if tasks %}
    {% for task in tasks %}
    <div class="flex mb-4 items-center">
      <p class="w-full text-grey-darkest">
        <a href="#">{{ task.name }}</a>
      </p>
      <button
        class="flex-no-shrink p-2 ml-2 border-2 rounded text-red border-red hover:text-white hover:bg-red bg-red-600"
      >
        Remove
      </button>
    </div>
    {% endfor %}
    {% else %}
    <p class="text-center">No Task to display</p>
    {% endif %}
  </div>
</div>
{% endblock content %}

Open your browser, you'll see a list of tasks.

Add new data

Let's create a new task from html templates

Change the home fonction
app.py

from flask import Flask, render_template, request, redirect  # add
from flask_sqlalchemy import SQLAlchemy  # add
from datetime import datetime  # add

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///todo.db'  # add
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False  # add
db = SQLAlchemy(app)  # add

# add


class Task(db.Model):
   id = db.Column(db.Integer, primary_key=True)
   name = db.Column(db.String(80), nullable=False)
   created_at = db.Column(db.DateTime, nullable=False,
                          default=datetime.now)

   def __repr__(self):
       return f'Todo : {self.name}'


@app.route("/", methods=['POST', 'GET'])
def home():
   if request.method == "POST": # add
       name = request.form['name']
       new_task = Task(name=name)
       db.session.add(new_task)
       db.session.commit()
       return redirect('/')
   else:
       tasks = Task.query.order_by(Task.created_at).all()  # add
   return render_template("home.html", tasks=tasks)  # add


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

home.html

{% extends "base.html" %}
{% block content %}
<div class="bg-white rounded shadow p-6 m-4 w-full lg:w-3/4 lg:max-w-lg">
  <div class="mb-4">
    <h1 class="text-grey-darkest">Flask Todo List</h1>
    <div class="flex mt-4">
      {% include "partials/_form.html" %}
    </div>
  </div>
  <div>
    {% if tasks %}
    {% for task in tasks %}
    <div class="flex mb-4 items-center">
      <p class="w-full text-grey-darkest">
        <a href="#">{{ task.name }}</a>
      </p>
      <button
        class="flex-no-shrink p-2 ml-2 border-2 rounded text-red border-red hover:text-white hover:bg-red bg-red-600"
      >
        Remove
      </button>
    </div>
    {% endfor %}
    {% else %}

    <p class="text-center">No Task to display</p>

    {% endif %}
  </div>
</div>
{% endblock content %}

Create a new folder inside templates, rename it partials and put the form into it.

partials/_form.html

<form action="/" method="post" class="inline-flex">
  <input
    class="shadow appearance-none border rounded w-full py-2 px-3 mr-4 text-grey-darker"
    placeholder="Add Todo"
    type="text"
    name="name"
  />
  <button
    class="flex-no-shrink p-2 border-2 rounded text-teal border-teal hover:text-white hover:bg-teal bg-green-600"
    type="submit"
  >
    Add
  </button>
</form>

Now you can add new task, retrieve all tasks, what about remove a task ?
Let's do it

Remove data

In app.py

# remove a task
...
@app.route('/delete/<int:id>')
def delete(id):
   task = Task.query.get_or_404(id)

   try:
       db.session.delete(task)
       db.session.commit()
       return redirect('/')
   except Exception:
       return "There was a problem deleting data."
...

In home.html

...
<a
  class="flex-no-shrink p-2 ml-2 border-2 rounded text-red border-red hover:text-white hover:bg-red bg-red-600"
  href="/delete/{{ task.id }}"
>
  Remove
</a>
...

It's very simple and intuitive, the last part before moving to production is the update task

Update data

In app.py

...

# update task
@app.route('/update/<int:id>', methods=['GET', 'POST'])
def update(id):
   task = Task.query.get_or_404(id)

   if request.method == 'POST':
       task.name = request.form['name']

       try:
           db.session.commit()
           return redirect('/')
       except:
           return "There was a problem updating data."

   else:
       title = "Update Task"
       return render_template('update.html', title=title, task=task)
...

In update.html

{% extends 'base.html' %}
{% block content %}
<div class="mb-4">
  <h1 class="text-grey-darkest">{{ title }}</h1>
  <div class="flex mt-4">
    <form action="/update/{{ task.id }}" method="post" class="inline-flex">
      <input
        class="shadow appearance-none border rounded w-full py-2 px-3 mr-4 text-grey-darker"
        placeholder="Add Todo"
        type="text"
        name="name"
        value="{{ task.name }}"
      />
      <button
        class="flex-no-shrink p-2 border-2 rounded text-teal border-teal hover:text-white hover:bg-teal bg-green-600"
        type="submit"
      >
        Update
      </button>
    </form>
  </div>
</div>

{% endblock content %}

Now we have fully functional Flask app, but if we wanna show the world our new app ?

Let's deploy the application using Heroku

Deploy to Heroku

Initialize a new git repository

$ git init
$ touch .gitignore
...

In .gitignore file add :

# Created by https://www.gitignore.io/api/flask
# Edit at https://www.gitignore.io/?templates=flask

### Flask ###
instance/*
!instance/.gitignore
.webassets-cache

### Flask.Python Stack ###
# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class

# C extensions
*.so

# Distribution / packaging
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST

# PyInstaller
#  Usually these files are written by a python script from a template
#  before PyInstaller builds the exe, so as to inject date/other infos into it.
*.manifest
*.spec

# Installer logs
pip-log.txt
pip-delete-this-directory.txt

# Unit test / coverage reports
htmlcov/
.tox/
.nox/
.coverage
.coverage.*
.cache
nosetests.xml
coverage.xml
*.cover
.hypothesis/
.pytest_cache/

# Translations
*.mo
*.pot

# Scrapy stuff:
.scrapy

# Sphinx documentation
docs/_build/

# PyBuilder
target/

# pyenv
.python-version

# pipenv
#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
#   However, in case of collaboration, if having platform-specific dependencies or dependencies
#   having no cross-platform support, pipenv may install dependencies that don't work, or not
#   install all needed dependencies.
#Pipfile.lock

# celery beat schedule file
celerybeat-schedule

# SageMath parsed files
*.sage.py

# Spyder project settings
.spyderproject
.spyproject

# Rope project settings
.ropeproject

# Mr Developer
.mr.developer.cfg
.project
.pydevproject

# mkdocs documentation
/site

# mypy
.mypy_cache/
.dmypy.json
dmypy.json

# Pyre type checker
.pyre/

# End of https://www.gitignore.io/api/flask

Create Procfile and add :

$ touch Procfile
...

web: gunicorn app:app

$ heroku login
...

Commit your code to the repository

$ git add .
$ git commit -m "Initial commit"
...

Create a new app on Heroku

heroku create flasktailwindtodo

Deploy your app to Heroku

$ git push heroku master
#...

Open your browser from the terminal using Heroku

$ heroku open
#...

Congrats 😍 See you in next Tutorial

How to build production-ready application with Django and PostgreSQL

Ousseynou Diop — Thu, 13 Feb 2020 20:58:55 +0000

Originally posted on my blog

Introduction

Build basic application everyone can do it but build real world production-ready application require lot of work.

In this guide i will show you how to build production-ready application with Django and Postgresql.

Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design.

RDBMS is a database management system (DBMS) that is based on the relational model as introduced by E. F. Codd.

PostgreSQL is The World's Most Advanced Open Source Relational Database.

Prerequisites

I assume that you've some basic knowledge of Django and want to know how to make your application production-ready.

Installation

The first step in this guide is to install the pieces we need in order to use postgresql.

The following command will install all packages

sudo apt install python3-pip python3-dev libpq-dev postgresql postgresql-contrib

I will use pipenv for dependencies management.

This command will install pipenv on your system

pip install --user pipenv

New Django project

Create a new folder and call it what you want

$ mkdir django_postgres
$ cd django_postgres

Create a virtual environment with pipenv

$ pipenv shell

Here is the output of the command

Creating a virtualenv for this project…
Using /usr/bin/python3 (3.7.5) to create virtualenv…
⠋Already using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/username/.local/share/virtualenvs/django_postgres-6CspIPh4/bin/python3
Also creating executable in /home/username/.local/share/virtualenvs/django_postgres-6CspIPh4/bin/python
Installing setuptools, pip, wheel...
done.

Virtualenv location: /home/username/.local/share/virtualenvs/django_postgres-6CspIPh4
Creating a Pipfile for this project…
Spawning environment shell (/usr/bin/zsh). Use 'exit' to leave.

Install Django

$ pipenv install django

The output of this command

Installing django…
Looking in indexes: https://pypi.python.org/simple
Collecting django
 Using cached Django-3.0.3-py3-none-any.whl (7.5 MB)
Collecting asgiref~=3.2
 Using cached asgiref-3.2.3-py2.py3-none-any.whl (18 kB)
Collecting sqlparse>=0.2.2
 Using cached sqlparse-0.3.0-py2.py3-none-any.whl (39 kB)
Collecting pytz
 Using cached pytz-2019.3-py2.py3-none-any.whl (509 kB)
Installing collected packages: asgiref, sqlparse, pytz, django
Successfully installed asgiref-3.2.3 django-3.0.3 pytz-2019.3 sqlparse-0.3.0

Adding django to Pipfile's [packages]…
Pipfile.lock not found, creating…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
Updated Pipfile.lock (7ff369)!
Installing dependencies from Pipfile.lock (7ff369)…
 🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 4/4 — 00:00:00

Install postgresql driver

$ pipenv install psycopg2-binary

The output

Installing psycopg2-binary…
Looking in indexes: https://pypi.python.org/simple
Collecting psycopg2-binary
 Using cached psycopg2_binary-2.8.4-cp37-cp37m-manylinux1_x86_64.whl (2.9 MB)
Installing collected packages: psycopg2-binary
Successfully installed psycopg2-binary-2.8.4

Adding psycopg2-binary to Pipfile's [packages]…
Pipfile.lock (7ff369) out of date, updating to (c90257)…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
Updated Pipfile.lock (c90257)!
Installing dependencies from Pipfile.lock (c90257)…
 🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 5/5 — 00:00:01

Create a new Django project

The following command will create a new django project for us

$ django-admin startproject prodapplication

Go to settings.py you will see a database configuration like this

# Database
# https://docs.djangoproject.com/en/3.0/ref/settings/#databases

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.sqlite3',
       'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
   }
}

SQlite is the default database for any Django project it help us to quickly prototyping a new idea.

Postgres Database & User Setup

Now logged into the postgresql shell

$ sudo -u postgres psql

Create a database

CREATE DATABASE datbase_name;

Create user

CREATE USER <username> WITH PASSWORD <password>;

Set default encoding, transaction isolation scheme (Recommended from Django)

ALTER ROLE <username> SET client_encoding TO 'utf8';
ALTER ROLE <username> SET default_transaction_isolation TO 'read committed';
ALTER ROLE <username> SET timezone TO 'UTC';

Give User access to database

GRANT ALL PRIVILEGES ON DATABASE <datbase_name> TO <username>;

Quit out the shell

\q

Manage dependencies

You can use Pipfile if you use pipenv or create a requirements.txt file and put your dependencies on it.

Ready to go

We've everything installed, now it’s time to do some production stuff.

Create a new file

I create a new file and called it local_settings.py, we will put all the production settings on this file.

Here is our folder structure

.
├── Pipfile
├── Pipfile.lock
└── prodapplication
   ├── manage.py
   └── prodapplication
       ├── asgi.py
       ├── __init__.py
       ├── local_settings.py
       ├── settings.py
       ├── urls.py
       └── wsgi.py

Change Debug mode to False

DEBUG = False

Change allowed host

ALLOWED_HOSTS = ['Your ip', 'www.domain.com', 'domain.com']

Change The secret key

I use this tool to generate a Django secret key

SECRET_KEY = <your new secret key>

Change the default database

DATABASES = {
   'default': {
       'ENGINE': 'django.db.backends.postgresql_psycopg2',
       'HOST': 'localhost',
       'NAME': '<database_name>',
       'USER': '<username>',
       'PASSWORD': '<password>',
       'PORT': '5432',
   }
}

Configure your mail server

# Email config
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = '<your smtp server>'
EMAIL_PORT = 587
EMAIL_HOST_USER = 'username'
EMAIL_HOST_PASSWORD = 'password'
EMAIL_USE_TLS = True

Import the new configuration

Put the following code in your settings.py

try:
   from .local_settings import *
except ImportError:
   pass

Test your new application

Run the following command

$ python manage.py migrate
$ python manage.py runserver

Conclusion

Performance is very important if it come to the real word application and you must optimise your application and configure it in a way that perform well.
One of the key is to use a production-ready Database, like postgresql.

In this guide you've learned how to write a production Django application.

Thanks for reading.

Security: How to secure your VPS server

Ousseynou Diop — Wed, 29 Jan 2020 16:48:16 +0000

Originally posted on my blog

A virtual private server (VPS) is a virtual machine sold as a service by an Internet hosting service. The virtual dedicated server (VDS) also has a similar meaning.

Wikipedia

In the modern world, It's impossible to feel 100% secure and safe, vulnerabilities are everywhere.

The security industry is one of the fastest growing industries in the world today, every day compagnies complain about hacking or some security issue, what ever the size of your company you must be conscience about hacking and hacker.
In this modern age, security is very important.

Security should be one of your priorities, physics and logics.

In this article i will share with you some tips to secure your VPS server.

1- Upgrade your system

Three reason to upgrade your system

1- Get full advantages of new features and functionalities
2- Bug fixes and Security improvement
3- Remove some outdated packages

Before you update your system make sure you have created a new user different of the default user AKA root.

Login To Your Server

$ ssh root@<your.ip.address>

root@<servername>:~#

Create a new user

$ adduser <username>

Give root privileges

$ usermod -aG sudo <username>

Create SSH Keys

SSH keys provide a more secure way of logging into a server with SSH than using a password alone.

Do this in your machine and hit enter all the way through it will generate a public and private key.

ssh-keygen

Copy the public key

$ cat ~/.ssh/id_rsa.pub

In your server

$ cd /home/username/
$ mkdir .ssh
cd .ssh
nano authorized_keys
Paste the key and hit "ctrl-x", hit "y" to save and "enter" to exit

Login as new user

$ ssh username@<your.ip.address>

Run this command to update the packages :

$ sudo apt update
$ sudo apt upgrade

2- Disable Root Login

Security expert highly recommended to not use root user .

$ sudo nano /etc/ssh/sshd_config

Make some changes

PermitRootLogin no
PasswordAuthentication no

Reload sshd service

$ sudo systemctl reload sshd

3- Configure a FireWall

In this article i use ufw firewall, is very easy to setup and it's good for most use cases.

See which apps are registered with the firewall

$ sudo ufw app list

Allow openSSH

$ sudo ufw allow OpenSSH

Check the status

$ sudo ufw status

4- Install Fail2Ban

Fail2ban is a log-parsing solution that monitors system logs for symptoms of an automated attack on your Server.
Basically, Fail2ban scans log files (e.g. /var/log/apache/error_log) and bans IPs that show the malicious signs -- too many password failures, seeking for exploits, etc.

$ apt-get install fail2ban

The system will start automatically

In order to get it work right you need to configure it and the article can't cover all the details, you can find online resources.

Thank you for reading.

Any tips, idea or suggestion ?

Python : How to setup your Virtualenv correctly

Ousseynou Diop — Tue, 21 Jan 2020 11:07:58 +0000

Originally posted on my blog

Introduction

Pipenv is a dependency manager for Python projects. If you’re familiar with Node.js’ npm or Ruby’s bundler, it is similar in spirit to those tools.

Everytime you want to create a new Python project or you follow a new course, you get sucked with the VirtualEnv ?
What the heck virtualenv is ?
How you can setup it Correctly ?

Requirements

Python : 3.4 or later
pip

Package Manager VS Dependency Manager

Based on a StackOverFlow answer

Package Manager - is used to configure the system, ie to setup your development environment, and with these settings you can build many projects.

Dependency Manager - Is specific to project. You manage all dependencies for a single project and those dependencies are going to be saved on your project. When you start another project you should manage your dependencies again.

Why we need it

The main purpose of using a dependency manager is to separate your application dependencies, that will give you the ability to use the one Framework in different project with different version.

A simple use case :

Imagine we have two(2) Django applications and we want to install differents versions of Django.

What we do ?

We've the choice to install all versions in one machine, but this is not the ideal way to do.

How to setup your virtualenv Correctly

Installation

As Pythonist we've many choices

Poetry
Pip
Pipenv
etc...

In this tutorial, we will use pipenv and i think is the easiest to setup.
And it is recommended for collaborative and Team projects.

Make sure you've Python and Pip installed in your machine

Let's check your installation

$ python --version

The output should look something like this

Python 3.7.5

And check the pip installation

$ pip --version

The output

pip 19.3.1 from /usr/local/lib/python3.7/dist-packages/pip (python 3.7

Installing pipenv using pip

$ pip install --user pipenv

Check the installation

$ pipenv --version

The output

pipenv, version 11.9.0

Create new project

$ mkdir test_pipen && cd test_pipenv
$ touch app.py

Installing packages for your project

$ pipenv install requests

Creating a virtualenv for this project…
Using /usr/bin/python3 (3.7.5) to create virtualenv…
⠋Already using interpreter /usr/bin/python3
Using base prefix '/usr'
New python executable in /home/username/.local/share/virtualenvs/test_pipenv-3gXMtvzy/bin/python3
Also creating executable in /home/username/.local/share/virtualenvs/test_pipenv-3gXMtvzy/bin/python
Installing setuptools, pip, wheel...
done.

Virtualenv location: /home/username/.local/share/virtualenvs/test_pipenv-3gXMtvzy
Creating a Pipfile for this project…
Installing requests…
Looking in indexes: https://pypi.python.org/simple
Collecting requests
 Using cached https://files.pythonhosted.org/packages/51/bd/23c926cd341ea6b7dd0b2a00aba99ae0f828be89d72b2190f27c11d4b7fb/requests-2.22.0-py2.py3-none-any.whl
Collecting idna<2.9,>=2.5
 Using cached https://files.pythonhosted.org/packages/14/2c/cd551d81dbe15200be1cf41cd03869a46fe7226e7450af7a6545bfc474c9/idna-2.8-py2.py3-none-any.whl
Collecting urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1
 Using cached https://files.pythonhosted.org/packages/b4/40/a9837291310ee1ccc242ceb6ebfd9eb21539649f193a7c8c86ba15b98539/urllib3-1.25.7-py2.py3-none-any.whl
Collecting chardet<3.1.0,>=3.0.2
 Using cached https://files.pythonhosted.org/packages/bc/a9/01ffebfb562e4274b6487b4bb1ddec7ca55ec7510b22e4c51f14098443b8/chardet-3.0.4-py2.py3-none-any.whl
Collecting certifi>=2017.4.17
 Using cached https://files.pythonhosted.org/packages/b9/63/df50cac98ea0d5b006c55a399c3bf1db9da7b5a24de7890bc9cfd5dd9e99/certifi-2019.11.28-py2.py3-none-any.whl
Installing collected packages: idna, urllib3, chardet, certifi, requests
Successfully installed certifi-2019.11.28 chardet-3.0.4 idna-2.8 requests-2.22.0 urllib3-1.25.7

Adding requests to Pipfile's [packages]…
Pipfile.lock not found, creating…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
Updated Pipfile.lock (5a8f8c)!
Installing dependencies from Pipfile.lock (5a8f8c)…
 🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 5/5 — 00:00:01

Activate your new environment

$ pipenv shell
$ (test_pipenv-3gXMtvzy) ....

Add this line in your app.py file

import requests

response = requests.get('https://httpbin.org/ip')

print('Your IP is {0}'.format(response.json()['origin']))

Run the application

$ python app.py

You should get output similar to this:

Your IP is 0.0.0.224, 0.0.0.224

See you next :-)