Forem: Developer Road

The Dev.to writing tips ✍🏽🚀

Daniel Diaz — Sun, 09 May 2021 14:47:45 +0000

Photo by Karolina Grabowska from Pexels.

Hi there, awesome people on the internet.

Today I want to make a compilation of the best writing tips according to Dev.to writers.

I start on the comment section. 😉

🤔 What really makes you a software developer?

Daniel Diaz — Sun, 18 Apr 2021 02:54:13 +0000

Why this question? 😃

Lastly, I'm trying to enhance my personal brand, and as a result of that, I've also had to describe myself.

I had the temptation of present myself as a software developer, but some doubts seized me.

What is in fact a software developer?

What makes you one?

How much time or experience do you need to be considered a software developer? 🤔

I'd like the incredible community of DEV to answer these questions and share knowledge, and opinions in the comments below 😌.

👨‍💻Best VsCode extensions for Python Developers🐍

Daniel Diaz — Mon, 12 Apr 2021 04:04:38 +0000

Why do you need good tools for create software? 🤔

Short answer

Really you don't, in fact you only need something to write code, and something for run it.

So what's the reason to spend time searching for the best tools?

Although you don't need anything extraordinary to build awesome applications, the tools that you use everyday help you to make it faster and with less errors. As a result you create better software in less time.

Currently one of the most used code editors is VScode, offered by Microsoft. I know that some of you are afraid of Microsoft as company, but lastly it has been one of the best organizations that are supporting the software developing environment. From Github, to Azure and as I mentioned the best code editor in the earth.

Best extensions in Vscode for Python apps.

Note: For install extensions run the command palette with Ctrl + p and paste the installation command. If you can't (For any reason), just search the extension name in the
extensions tab.

Python

The must have extension: ms-python

It has a lot of features like Intellisense, Formatting, debugging, snippets, etc ...

Also it installs for you the jupyter notebook extension!

Installation:

ext install ms-python.python

Python snippets

This extension give you a lot of abbreviations to avoid writing by yourself the same thing many times.Python snippets

Installation:

ext install frhtylcn.pythonsnippets

Python Docstrings

Documentation is important, and this extension allows you to create beautiful docstrings for you functions/classes: docstring generator

Installation:

ext install njpwerner.autodocstring

Python indent

Fix Python indentation each time you press Enter: Python indent

Installation:

ext install KevinRose.vsc-python-indent

Python testing

If you are creating large applications, you'll need tests for ensure that the code works properly. This extension allows you to run your tests directly from the VScode UI: Python test explorer

Installation:

ext install LittleFoxTeam.vscode-python-test-adapter

Real time Python Runner

Writing small applications requires rapid output checking. With this extension you can see the output of a python a file changing in real time: AREPL for python

Installation:

ext install almenPython frameworks extensionson.arepl

General purpose extensions

These extensions help you to create code effortlessly.

Indent Rainbow

This extension colorizes the indentation of your python file. It results really useful when the code has a lot of nested levels. Indent rainbow

Installation:

ext install oderwat.indent-rainbow

Better comments

This extension help you to create better comments, by highlighting special parts like TODO's, paramaters and queries. Better comments

Installation:

ext install aaron-bond.better-comments

Git lens

Working with Git? This extension give you super powers working with Git. Git lens

Installation:

ext install eamodio.gitlens

Extensions for Python frameworks

Django template language

The django extension allows you to create clean and well highlighted DTL templates. Django

Extension tip: This extension only works if you modify your settings file and add this json keys:

# SETTINGS_FOLDER/User/settings.json

"files.associations": {
    "**/*.html": "html",
    "**/templates/**/*.html": "django-html",
    "**/templates/**/*": "django-txt",
    "**/requirements{/**,*}.{txt,in}": "pip-requirements"
},

Installation:

ext install batisteo.vscode-django

Django snippets

Curated snippets for develop Django apps.Django snippets

Installation:

ext install bibhasdn.django-snippets

Extra

Beautify your workspace

You should make beautiful, the space you use many hours a day.

So let's take a look and what you can do:

Installing icons

Install the Vscode icons and you'll access to a bunch of file extensions icons.

Here is my preferred theme:

Cherry

Take a look at My blog,
to get access to more awesome articles like this one.
Please consider supporting me on Ko-fi you help me a lot to
continue building these tutorials!.

Any extension I left out of this list?, please let me know in the comments!

🚀🐧 What's your current OS and why do you use it?

Daniel Diaz — Wed, 07 Apr 2021 23:09:42 +0000

Show off your Operative system set up

I've been learning programming for over a year. But I've always been interested about the best tools available to achieve my objectives, and one of the most important is the OS.

Yeah, that thing that is processing all the tasks of our music players 🎵 and code editors 👨‍💻 the whole day.

My current OS

At this moment (April, 2021), I'm using a Linux based operative system called Manjaro.

For me it's almost perfect, because I can do whatever I want with the look and feeling of it, I can Install window managers like Qtile or Awesome, and I'm able to install practically any open source software available, due to the Arch User repositories.

And the best of all! I can use it in a low resources machine 😊.

Some screenshots of my desktop

Unfortunately this weekend I must to get rid of Manjaro in order to install Windows, because of school. (Some software is only available for windows 😓)

However I still able of install other Linux distribution alongside windows later 😁.

So my question is:

What operative system are you using and why?

Do you have any advantage for using it?

What is the most common software you use in your operative system, and does it retain you from changing?

What is the best part of it 🤔?

Lastly feel free to share your desktop screenshots, show off how beautiful is your daily driver 🖥️.

📂 Merge common words of two files in Python, practice file handling

Daniel Diaz — Sun, 21 Mar 2021 23:15:25 +0000

Hi there 😁

In this tutorial you will learn to select words from files, compare them and merge the common words in a new file.

You will practice 🔁

File handling in Python
Sets in Python
Using function to re use code
Some basics command line instruction

Let's start 🐍

Code: Remember that all the code shown during these tutorials will be pushed to github.

Developer-road / merge-common-words

Program to merge the common words of two files into another ones

merge-common-words

Program to merge the common words of two files into another ones

View on GitHub

First of all create a Python file, I'll use a long and descriptive file name merge.py 😆

Let's create that file with the terminal:

Note: if you are using windows, none of these commands will run, so just do all the things with a graphical interface, like a file manager of your code editor. If you are using Mac 🍎, or Linux 🐧 stay relaxed, and learn the terminal as best as you can.

Remember that Python is mainly a CLI programming language, so you will be using a lot the terminal, so my advice is to use the terminal whenever you can 😀

touch merge.py

The touch command will create an empty file merge.py, in the directory you are in.

Now I'm going to call a graphical editor, from the terminal 😱, in this case I'll use vscode.

code ./

Remember that in UNIX (don't be scared, it refers to Unix based OS, like Linux and Mac), ./ the dot refers to the current directory.

Now that I have Vscode set up and going let's start with the code.

Open a file in Python

First of all , we will use some text files in this tutorial, you can download them easily on github, by cloning the repository or just following the links below.

text_one.txt
text_two.txt

In Python you open a file with the function, open which takes as parameter the path of the file.

Make sure you've downloaded the text files, and type in the merge.py file the following code.

file1 = open("text_one.txt)

This will create a variable file1, which is a file object, with the mode of "read" (by default).

If you try to print that variable you will get something like this:


print(file1)

# Result
# <_io.TextIOWrapper name='text_one.txt' mode='r' encoding='UTF-8'>

That's because that variable is just a file object of the text file named, "text_one.txt"

But be carefully if the file doesn't exist, you will get an error 😱.

file1 = open("text_oness.txt")

# FileNotFoundError: [Errno 2] No such file or directory: 'text_oness.txt'

So each time we're working with files, we should use some defensive programming, to avoid the error in case the file doesn't exist

try:
    file1 = open("text_oness.txt")
except FileNotFoundError:
    print("Sorry that file doesn't exist")
    exit()

We're using the exit() function because if the file doesn't exist we won't have the variable to work with, so in that case we will terminate the execution.

If you want to get the content of a file in Python, you would use the {file_object}.read() function, that as it name says read for us the content of that file.

print(file1.read())

# Results
# Why should you learn to write programs?

# Writing programs (or programming) is a very creative 
# and rewarding activity. MORE TEXT .....

Now that you know how to open files, and read them you should be able to create that comparison functionality.

First make sure we are able to open the two files.

try:
    file1 = open("text_one.txt")
    file2 = open("text_two.txt")
except FileNotFoundError:
    print("Sorry that file doesn't exist")
    exit()

Now we will use the content of the files and the power of sets to get all the words of each file.

Sets in Python

A set in Python, is an unordered data structure, with a really special characteristic (Among others), it doesn't allow repeated elements 🤫.

We will use them, to be able to get the words, without repeating.

Creating a set in Python

To create a set in Python we will use the set() function.

empty_set = set()

A set VS a list:

mylist = list("122333")
myset = set("122333")

print(mylist)
print(myset)

# List:
# ['1', '2', '2', '3', '3', '3']

# Set
# {'3', '2', '1'}

As you see the list printed all the elements in order, but the set only printed the elements that were not repeated, and unordered.

Getting the words of a file

We are going to iterate through the words of the file with a for loop, and add them in a set for each file.

file1_words = set()

file2_words = set()


for word in file1.read().split():
    file1_words.add(word.lower())

for word in file2.read().split():
    file2_words.add(word.lower())

print(file1_words)
print(file2_words)

Maybe the above code is a little bit confusing, but let's take a quick look on it.

First we initialize, two sets, one for the first file, the another for the second file.

Then we iterate with a for loop, each word of the file by calling file1.read().split().

In that part we use the method read(), that gives us the content of the file as a string, and then we use the string method split(), which gives us a list of the words in the file by splitting the string within each space.

So basically we are iterating over:

for word in list_of_words_of_the_file:
    code...

Then we get the word, we make it lowercase to avoid word repeating, and add it to the file1_words set. Remember that in a set there can't be repeated elements, if a word is already in the set, then it won't be added.

We do the same thing for both files.

Running that piece of code, returns two sets with all the words of both files.

Challengue

But there is a problem and I challenge you 🔥 to solve it.
There are some words that have special punctuation, for example (on and on, and your task is to figure out how to replace all the punctuation characters, so there won't be repeated words, but with special punctuation.

Reach me out on Twitter, or Instagram, if you achieve it.

Using sets to intersect common words

We are looking for common words in the sets we just created, and for that we will use Intersection.

Yeah that word may look scary since probably you've seen it in math, but don't worry. Intersection are just the common parts of two sets.

Intersecting elements could be tedious 🙄, since with most data structures you would have to iterate through the variables that contain the elements, compare them select those that are repeated and append them in a new variable.

But with sets in Python, we have a special function that does all of that for us, {set1}.intersection({set2})

common_words = file1_words.intersection(file2_words)

print(common_words)

There it is, now we can access the common words of the two files, in an one liner.

Writing files in Python

Writing files in Python, is not that hard. We open a file in write mode by using open("file/path", mode = "w").

This allow us to write to an existing file or in the case the file didn't exist, it creates a new one with the determinate file path.

So let's open our merge file.

merge_file = open("merge.txt", mode = "w")

# code_here ....

merge_file.close()

Remember that every time we open a file in write mode, we must close it, after making the desired operations.

Now we're going to write all the common words to the new merge.txt file.

merge_file = open("merge.txt", mode = "w")

for word in common_words:
   word = word + ", "
   merge_file.write(word)

merge_file.close()

We need to append a comma string at the end of each word, so we can differentiate the words in the file.

If you run this code, you will get the desired result.

try:
    file1 = open("text_one.txt")
    file2 = open("text_two.txt")
except FileNotFoundError:
    print("Sorry that file doesn't exist")
    exit()


file1_words = set()

file2_words = set()


for word in file1.read().split():

    file1_words.add(word.lower())

for word in file2.read().split():

    file2_words.add(word.lower())


common_words = file1_words.intersection(file2_words)

merge_file = open("merge.txt", mode="w")

for word in common_words:
    word = word + ", "
    merge_file.write(word)

merge_file.close()

If you check the new "merge.txt" file, you will see all the common words between the file text_one.txt and text_two.txt

Congratulations 🎉, you just created a merge algorithm, and in base of a merge algorithm (Much more complex for sure), is how git works, to compare code files.

But wait a minute, this code is clunky and there are many parts where we repeated the same process.

So let's use the power of functions, to make our code reusable and more escalable code.

First let's make a function to open a file, and handling exceptions. That function will take 2 arguments, the first will be the file path, and the second an optional argument with the open mode of the file.

# Python function that handle exception while opening files

def open_file(file_path, open_mode="r"):

    try:
        file_handler = open(file_path, mode=open_mode)

    except FileNotFoundError:
        print(f"Sorry the file {file_path} doesn't exist")
        exit()

    except ValueError:
        print(f"Sorry the file {file_path} can't be opened with mode {open_mode}")
        exit()

    return file_handler

Then a function that let us catch the words of a file.

def get_file_words(file_path):

    file_words = set()

    read_file = open_file(file_path)

    for word in read_file.read().split():

        file_words.add(word.lower())
    return file_words

Here as you may notice, we take as parameter the path of the file we're going to get the words from, and get the file handler through the open_file() function, we just created.

Lastly let's create a function merge, which will make the operations of getting and intersecting the common words, and writing those words in a file.

def merge(*filenames, merge_file="merge.txt"):

    list_of_file_words = []

    for filename in filenames:

        file_words = get_file_words(filename)
        list_of_file_words.append(file_words)

    common_words = set.intersection(*list_of_file_words)

    merge_write_file = open_file(merge_file, "w")

    for word in common_words:

        word = word + ", "

        merge_write_file.write(word)

    merge_write_file.close()

Here we use the power of *args in python functions, that allow us to pass multiple filenames to the function if we want to merge more than two.

You can notice that I used a for loop to iterate over the *filename argument. That's because we can receive any number of filenames now, and thus our merge algorithm is more powerful now.

Compacting our code in a main() function

As a best practice in python, you can use a main() function, that will call and perform any operation your script does.

def main():

    file1 = "text_one.txt"

    file2 = "text_two.txt"

    merge(file1, file2, merge_file = "main_merge.txt")

This main function calls the merge function and pass as parameters the file1 and file2 variables. Also we specified the merge_file parameter which tells the merge function which file it has to write in.

But as you may noticed we haven't call any function yet, so let's call the main function.

if __name__ == "__main__":
    main()

The __name__ variable deserves another blog post, but basically here you're telling to python:

Hey dude 🥸, if this is the python file you're executing from terminal, run the main() function.

So the final code of this cool algorithm is this:

def open_file(file_path, open_mode="r"):

    try:
        file_handler = open(file_path, mode=open_mode)

    except FileNotFoundError:
        print(f"Sorry the file {file_path} doesn't exist")
        exit()

    except ValueError:
        print(f"Sorry the file {file_path} can't be opened with mode {open_mode}")
        exit()

    return file_handler            


def get_file_words(file_path):

    file_words = set()

    read_file = open_file(file_path)

    for word in read_file.read().split():

        file_words.add(word.lower())

    return file_words

def merge(*filenames, merge_file="merge.txt"):

    list_of_file_words = []

    for filename in filenames:

        file_words = get_file_words(filename)
        list_of_file_words.append(file_words)

    common_words = set.intersection(*list_of_file_words)

    merge_write_file = open_file(merge_file, "w")

    for word in common_words:

        word = word + ", "

        merge_write_file.write(word)

    merge_write_file.close()



def main():

    file1 = "text_one.txt"

    file2 = "text_two.txt"

    merge(file1, file2, merge_file="merge_main.txt")


if __name__ == "__main__":
    main()

Conclusions:

In this tutorial you practiced:

File handling in Python
Sets and lists in Python
Iteration with for loops
Function definition and usage
Python main function best practices

If you found any error in this tutorial don't hesitate in contact me, or make a pull request in the Github repo

Follow me in My blog,
to get more awesome tutorials like this one.
Please consider supporting me on Ko-fi you help me a lot to
continue building this tutorials!.

🤖 🐍 Create your first Django app: Hello world app

Daniel Diaz — Mon, 08 Mar 2021 02:29:12 +0000

First of all! 😀

Take a good look at this article, that will give you a quick grasp of what is Django, and why you should use it!

What is Django, and why you should use it 🐍

Daniel Diaz for Developer Road ・ Mar 1 '21

#django #python #webdev #beginners

What you will learn 📖

Continuing with this article, here you will learn:

Install Django, (and it's dependencies)
Take a quick look at the Django Project structure.
The basics of the MVT pattern
Use the Django Template Language

Source code 💻

The source code of this tutorial is available in this Github repository:

Developer-road / django-hello-world

A simple Django hello world app

django-hello-world

A begginers hello world guide to the django web framework.

Install requirements:

python3 -venv .venv

source .venv/bin/activate


pip install -r requirements.txt

View on GitHub

Installation 🐍

First of all, you have to install Python, which is one of the most loved languages in the world, and Django is built with it!

Check out the python downloads page

And install the Python 3 version for your operative system: Windows, Mac or Linux

Reminder: Most of Linux distributions, comes with Python Preinstalled so you don't have to worry about install it.

Terminal

Now it's time to use the terminal, or Command line interface 😨 . I know it can be scaring to use the terminal for the first time, but it is an essential skill, that I think every developer should have.

Depending in your operating system, you have different terminal emulators installed, so let's take a look of each terminal for Different OS.

Windows

In windows you have to preinstalled options, CMD and Powershell. Both are terrible 😂, but you can get the job done with them.

Note: In windows the file structure is different from UNIX based (Mac OS and Linux), so usually I recommend to install Git bash, that lets you to run the same commands I'll be using in this tutorial, but I let it up to you.

Mac OS and Linux

In these operative systems, you have built in terminals and you can search it directly in your programs search bar.

In my case 😀

Also if you find too complex to use your system terminal, just use integrated terminals from different code editors

For example Vs Code

Verifying Python Installation

Now that you know to open up your terminal, let's check if we have Python installed

python --version

If I run this command I get:

Which means that the Python version. I have installed in my system is Python 3.8.6.

Also check for pip

pip stands for PIP install packages. It is a Python package manager, that will allow us to install different useful packages, included Django 😆

To check if pip installed, we use

pip --version

As you see, I have pip 20.3.3 installed

Installing Django

Before we can install Django, we should set up a virtual environment, to do that, we run

python -m .venv

This will create a Virtual environment with the name of .venv.

If you want to know more about virtual environments, just take a look on this post.

🧠 Tutorial: Understand Virtual environments in Python ✅

Daniel Diaz for Developer Road ・ Feb 27 '21

#python #virtualenv #tutorial #programming

Now activate that virtual environment 😀

source .venv/bin/activate

You can easily install Django, with a simple pip command

pip install django

You will see something like this in your terminal

Lastly confirm your django installation

╰(.venv)─λ pip freeze                                                                                  0 (0.003s) < 21:15:55
asgiref==3.3.1
Django==3.1.7
pytz==2021.1
sqlparse==0.4.1

As you see I installed Django 3.1.7, which is the latest version of Django, in this moment.

Advice: I always recommend to use the latest django version, since it has the more patches and security fixes.

But if you are already working with a team, or for a company with an older Django version, you should continue using it.

Anyways the Django project team, had been doing an amazing job, because no matter if you learn the Django 3.x version, 2.x or even 1.x (Don't use it please 😆), most of the core functionality still the same.

Creating a project

To create a project in django, you will use the following command

django-admin startproject helloworld

This will create a folder name helloworld, and inside that folder, there will be another folder named hellowold, and a Python file manage.py

╰(.venv)─λ tree                                                                                        .
├── helloworld
│   ├── helloworld
│   │   ├── asgi.py
│   │   ├── __init__.py
│   │   ├── settings.py
│   │   ├── urls.py
│   │   └── wsgi.py
│   └── manage.py

I know this file structure could be confuse 😕, so I'll explain it in detail.

Django double folder structure

As you may notice, when you create a project in Django, there will be two folders named the same, but these two have differences.

The root folder /helloworld is just like a container, it doesn't matter for django, and it is only there for organization purposes.

You can rename it with whatever you want.

In the other hand there is the inside folder /helloworld/helloworld. It is a Python package since it has a __init__.py.

We will use it to configure our Django project, and to import everything from other apps. (Later we'll see what is an app 😉).

Inside the helloworld package, we can found another important files:

__init__.py, indicates that the project folder must be considered as a package
settings.py, used to configure our app.
urls.py, lets you add or remove url patterns
wsgi.py & asgi.py, configure your deploy server

Finally the manage.py file, is a command line utility that let us interact with the Django framework.

Running a development server.

To run a local server, run the following command

python manage.py runserver

You can specify a port for the server. So this time I'll use the port 8080, as an demonstration.

python manage.py runserver 8080

Note: You will see warning about migrations, but don't worry you will not manage them in this tutorial.

After running that command, go to your browser and type:

# Or the port you used in the runserver command
localhost:8080

After doing that, you should get a page like this, that confirms the installation

Ok, you got it. You installed your first Django project 🦄

Now let's go with the interesting part 😁

Using the MVT pattern

Before continue, I want to tell you about the MVT pattern or Model, View, Template. I know that it sounds confusing, but please don't turn off your brain 🧠, and don't give up 👏.

First of all, why Django uses this pattern? 💭

Django uses this pattern, because it allows the developer, to skip the tedious part of creating a custom controller.

Now, let's get into the different parts of this design pattern:

Model: Holds all of the logical structure of your database. It manages all of the operations, in the database, like creating, updating and deleting.

Due to the models, we as Django Developers mustn't learn SQL 💽 (although it would be a good plus).

View: As a quick definition, a view receives a request, and return a response. Usually the view receives a HTTP response, like GET, and return a html file, or a Json file, or nearly everything.

That return of html files, is called *Template *.

Template: Is what is shown to the user, if everything results Ok with his/her request. It acts as a presentation layer, and you can write them with html, css, javascript, and a special language: The Django template language.

These templates, are designed to "Don't repeat yourself", since Django uses a special language DTL, to build them.

Creating the hello world app

Since this is a beginners guide, we will only use, Urls, Views and templates 😉.

Creating an app

Before continuing, we're going to create a django app.

django-admin startapp myapp

Our app is called myapp, and it contains several files and a strange folder named migrations 😮.

Let's take a look at the structure of our app.

. myapp/
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
└── views.py

1 directory, 7 files

admin.py : Here we can register our models in the admin page (We will see it in next articles)
tests.py : This file is where we make our unit tests.
models.py : Where we create our models, and where we interact with our database
apps.py : Configuration of our app. I've never touch it 😅
views.py : All of our business logic lives here. This file contains the views that will render our templates.
/migrations : Here is where migrations live. I'll create a post about it, but as a quick concept a migration is a recording of the changes of our models.

Differences app and a Project

Do you remember that we already created a project, called helloworld ?.

Well now we just created an app, and here are the differences.

Project	App
Collections of apps, for a website	Web application that does something
Can contain multiple apps	Can be in multiple projects
Ex: A Blog website	Ex: A comments app that can be in many projects, like Disqus

Until now, we haven't touched any code, so let's get into it.

Hands on 🙌

Installing our app:

We just created an app, so let's install it in the settings.py file

# helloworld/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # Custom apps
    'myapp',
]

After installed our new app, we can get into url patterns.
Go to the urls.py file, in our project folder and modify the following things.

from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),

    # The url path of our new app
    path('', include('myapp.urls')),
]

Here we imported the function include, that as the name suggests include the url patterns of external apps 😀.

Then we created another path, with the destination of '', that means that when a user hits the url, without any other pattern, we call the urls of the app myapp

As you may noticed, we are calling the urls as a Python package, so myapp.urls means:

Go to the myapp package
Extract the url patterns of the urls.py file.

But you would say me: Daniel! are you crazy 🤯, that file hasn't been created.

And yeah, you are right. So we need to create it manually.

You can create it from your code editor, or from your terminal

cd myapp/

touch urls.py

After creating that file, we are going to made the fun stuff! 😝

Creating our first view:

Let's edit our views.py file.


from django.http import HttpResponse

# Create your views here.


def helloworldview(request):

    response = "Hello world, this is my first Django app! :)"


    return HttpResponse(response)

Here we imported the HttpResponse class and we passed a variable response, with a value of: "Hello world .."

Ok cool, but next we have to create an url for that view, let's go to the myapp/urls.py file.

from django.urls import path

from .views import helloworldview

urlpatterns = [
    path("", helloworld),
]

As in the urls.py of the project folder, we imported path, and created url patterns for our app. Also we used a new concept, we passed a view to our path function.

All of the stuff we just do, means that each time that we hit localhost:8000, we request the url pattern of "".

That url will call our view function named helloworldview, that takes our request, and returns a HttpResponse, with the content of "Hello world".

Not that hard to understand, right 😅?

Now run the server, and watch your first app working!

python manage.py runserver

# See it on localhost:8000

Using Django templates

The last part of this tutorial will be about, Templates in Django 😀

First of all a Django template, is a html document, that uses the Django template language, to incorporate data and logic on our front end.

Your first template in Django

Before using templates, we need to create a folder in our app to be able to use it.

So let's create one:

cd myapp/

mkdir templates

You just created a directory, named templates. That tells Django to search for templates in that folder.

Create a file, named index.html, that will be our first template.

touch index.html

Now, paste the following html, in the template.

<h1>Hello world, this is my first template</h1>

<p>This is a cool html paragraph!</p>

After that we are going to modify the helloworldview, in order to render our template

from django.shortcuts import render

def helloworldview(request):

    template = "index.html"

    context = {}    

    return render(request, template, context)

Here, we used the function render, that takes as parameters, the user request, the name of the template, in this case index.html, and the context, that we will see how to use it later.

After that minor changes, you'll see something like this.

Using the DTL

Now we will see the basics of Django template language.

Create a file base.html, inside the templates folder.

touch base.html

There we will paste the basic structure of a html Document.

<!DOCTYPE html>
<html lang="en">

    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Django Hello world</title>
    </head>

    <body>
        {% block body %}


        {% endblock body %}


    </body>

</html>

But with a little change we are using DTL tags. Those are of the shape {% tag %}. The tag we used in this case, is:

{% block [name of the block] %}


{% endblock [name of the block] %}

That tags, allow us to put html code, in block codes, as we are going to see now.

Template inheritance 😁

Now modify, the index.html file.

{% extends 'base.html' %}

{% block body %}
<h1>Hello world, this is my first template</h1>

<p>This is a cool html paragraph!</p>


{% endblock body %}

Here we just do a strange thing! 🤯, we used template inheritance, and DTL blocks.

You call, the inheritance with the tag {% extends "name of template" %}

And with the block tag you replace the content inside the block

{% block [name of block] %}
... Replaced content

{% endblock [name of block] %}

If we look at the source page of our page, we get something like this.

<!DOCTYPE html>
<html lang="en">

    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Django Hello world</title>
    </head>

    <body>

<h1>Hello world, this is my first template</h1>

<p>This is a cool html paragraph!</p>



    </body>

</html>

Context variables and for loops

We are going to pass context variables from our views. so let's modify the view

def helloworldview(request):

    template = "index.html"

    people = ["daniel", "nicolas", "tom", "henry"]

    context = {"people": people}    

    return render(request, template, context)

We are passing, a context dictionary to our template. Our key "people" is a list of strings.

Now we are going to make a for loop, to iterate through that list 😁.

{% extends 'base.html' %}

{% block body %}
<h1>Hello world, this is my first template</h1>

<p>This is a cool html paragraph!</p>


{% for person in people %}
    <p>{{person}}</p>
{% endfor %}


{% endblock body %}

As you may notice, the for loops in DTL are exactly the same as they are in Python.

And variables, in DTL are represented with {{ name_variable }}

If we check our server, we'll get something like
this. 🤯

Amazing, it isn't ?

Conclusion:

In this tutorial, you learned the basics of django.

From creating function based views, to building url patterns and using the Django template language 😃.

Any questions or doubts ? Let me know in the comments

Follow me in My blog,
to get more awesome tutorials like this one.
Please consider supporting me on Ko-fi you help me a lot to
continue building this tutorials!.

🐘 Set up A PostgreSql Database in Django

Daniel Diaz — Fri, 05 Mar 2021 01:44:36 +0000

Quick advice:

If you want a post that covers the deploy of a Django app, entirely go to this one

🎯 Tutorial: Deploying a Django app on Heroku

Daniel Diaz for Developer Road ・ Feb 18 '21

#heroku #deploy #devops #django

Creating an app on heroku

Before you create a free app on heroku you must create an account, here.

Once you have created your account, you will have a dashboard like this one.

To create an app click in New, and you will see a dropdown, with the option of Create new app.

Choose that, select a name and click on create app.

Now that you've created a new app, click in "Overview", and select configure addons.

Now search for heroku postgres and select it.

Modifying your settings file

Now you are almost ready to deploy to heroku, but first let's modify your settings, to be ready to be deployed.

Install django_heroku and python decouple

pip install gunicorn django-heroku python-decouple

I'll be only explaining the database set up, for other instructions, just read this tutorial

Using dj_database_url

dj_database_url is a package that comes bundled, with django_heroku.

It's function dj_database_url.config(), receives as a parameter the url config of a database, and transform that in the needed keys to get access to it.

Modifying:

# Import this packages previously dowloaded

import django_heroku
import dj_database_url
from decouple import config

# Go down until you find database stuff

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


# Commment out the sqlite database setup

# DATABASES = {
#     'default': {
#         'ENGINE': 'django.db.backends.sqlite3',
#         'NAME': BASE_DIR / 'db.sqlite3',
#     }
# }

# These lines make all the magic
DATABASES = {
    'default': dj_database_url.config(
        default=config('DATABASE_URL')
    )
}

Create a Procfile

Run this in the root directory of the app

touch Procfile

Open the file and copy the following line:

web: gunicorn (Your app).wsgi

This tells Heroku, that it must run a web process, with gunicorn as HTTP server and with a wsgi file located in (Your app). Remember to change (Your app) with the name of your project.

Freezing requirements.txt

To freeze a file with the requirements of your application, just run

pip freeze > requirements.txt

Heroku will search for that file, so don't forget to run that command.

Managing the deploy with Github

Deploys with Github are way easier than with the Heroku CLI tool, so don't forget to create a repository on Github with the app you are trying to deploy.

Push the changes you've made with

git add -A
git commit -m "Database Settings ready"
git push origin

Now in the heroku website, go to the Deploy tab and click in Connect with github.

You will be redirected, to Github in order to authorize access to your repos.

Now connect the repo you want to deploy

And finally in Manual deploy, click on Deploy branch.

Wait for it, if you get errors ....

Well just read the Heroku docs , or comment below your problems.

Thanks for your time hopefully this tutorial will be useful for you 🤗.

Follow me in My blog,
to get more awesome tutorials like this one.
Please consider supporting me on Ko-fi you help me a lot to
continue building this tutorials!.

💸 Django Tutorial: Set up Media files in Deployment for FREE

Daniel Diaz — Fri, 05 Mar 2021 00:50:23 +0000

In this tutorial, you will learn to manage your media files during deployment, (and even production) for free.

Cloudinary

We will use cloudinary, for that purpose. It will allow us to manage our media (Uploaded files), in Django, with just a few modifications in our settings file.

Differences between Static Files and Media Files

In web development, static files are those files that stay "static", which means that those files aren't modified at any moment of the user interacting with the site.

The main three static files are CSS, Javascript, and images, which are served in our templates.

In Django apps deployment we use, whitenoise for managing static files. Since Django by itself is not able to manage static files during development (Because of performance issues).

Media Files

On the other hand, media files are files uploaded by the users of your application. That means that these files are constantly changing, and therefore require their own way to be served.

Cloudinary storage

To use the Cloudinary storage API, we're going to create a free account, here.

Hit in create an account, and verify your account with your email.

You will get a Dashboard with your Credentials, We'll use them later 😉.

Modifying the settings:

First of all, we will need the Cloudinary packages, to be able to use it as a media manager. So let's install some packages.

pip install cloudinary django-cloudinary-storage

Now let's import, a couple of modules

# At the top of the settings
import cloudinary
import cloudinary_storage

And modify the installed apps

INSTALLED_APPS = [
    # Other apps ...

    # Media Cloudinary
    'cloudinary',
    'cloudinary_storage',
]

Last but not least, paste the following code after, these comments

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.1/howto/static-files/

Like this.

# Cloudinary stuff
CLOUDINARY_STORAGE = {
    'CLOUD_NAME': <your cloud name>,
    'API_KEY': <your api key>,
    'API_SECRET': <your secret api>,
}

DEFAULT_FILE_STORAGE = 'cloudinary_storage.storage.MediaCloudinaryStorage'

But somebody would tell me: Hey, are you crazy? we are putting our credentials in an unprotected settings.py file.

And yeah, that's right!

So the idea is to protect our credentials, with Environmental Variables. That means that we're going to put all of our keys in the server, that we are going to deploy our code, and not in the source files.

You could use os.environ.get("Key"), but as I'm going to deploy my app to Heroku, I'll use Python Decouple.

If you want to learn, how to use Python decouple on Heroku, you definitely take a look at this tutorial.

In that case, our Cloudinary settings would be like this

from decouple import config

CLOUDINARY_STORAGE = {
    'CLOUD_NAME': config('CLOUD_NAME', default=""),
    'API_KEY': config('API_KEY', default=""),
    'API_SECRET': config('API_SECRET', default=""),
}

DEFAULT_FILE_STORAGE = 'cloudinary_storage.storage.MediaCloudinaryStorage'

Thanks for your time hopefully this tutorial will be useful for you 🤗.

Any doubts, or problems? Let me know in the comments.

What is Django, and why you should use it 🐍

Daniel Diaz — Mon, 01 Mar 2021 02:51:31 +0000

Django in 20 words (or less) 😅

Django is an open source and powerful web framework written in Python, that let you build web apps rapidly. 🚀

Who is using Django?

Django is one of the most used backend web frameworks, with over 10 thousand developers who use it to build amazing software.

Companies using Django

Absolutely, Django is being used by a lot of companies, some of the most remarkable are:

Instagram:

Instagram was built originally with Django, nowadays they use custom backend written in Python, but they still use the core functionality of Django.

Disqus:

Disqus is the most popular comment plugin available, and it was built purely with Django.

Spotify:

Spotify don't use Django as it's main backend, but spotify team use it to connect diverse services like Machine learning functionality, (Which is made with Python 😁)

Pinterest:

Some of the core functionality of Pinterest is made with Django, like sharing their boards or subscribing to users.

Best features

It's a Python framework! Python is one of the most used (and most loved) programming languages, it allows you to code rapidly and that's why Django results so effective.
Has a built in Authentication system Django has an excellent authentication system by default, also it is really secure and you don't need to install extra packages to build an application that requires it.
It uses MVT pattern Django has the MVT pattern: Model, View, Template

One of the main advantages of Django is that handles ALL the
database operations by itself, through the models, so you don't
have to know SQL.

Myths about Django

Node is better
There is not a framework that is better or worst. Node has its advantages, so has Django. The only thing that matters is what you are able to do with what you know.

Django is not escalable

Each time I hear that my head explodes 🤯. Some of the most escalable companies like Instagram, Pinterest, Disqus or Spotify has Django in their core so that is totally false.

What do you need to learn Django? 🤔

Although Django is a powerful web framework with batteries included, it could be also confusing if you don't have previous knowledge of the following concepts:

Basic Python concepts:
- Variables
- String operations
- Loops
- Conditionals
- Boolean expressions
- Functions
- Module imports
Object oriented Programming: You don't need to master it, but at least understand the basics
- Most important concept: Inheritance
Some Frontend basics (Totally optional):
- Basic Html
- Basic Css
- A little bit of Javascript (Even more optional)

Maybe in this moment you are feeling like this:

But don't get frustrated, programming isn't a sprint ⏱️, is a marathon🏃🏽‍♂️, and you have to plan your study plans to achieve your goals.

You can get the basics of Python, in around a week or two, Basic Object oriented Programming in another week, and you can learn basic Html and Css on the road.

So 🙅‍♂️ 0 excuses, if you think Django is a right choice for you START RIGHT NOW!.

I'm thinking about making a Django series, comment below if you want it.

Follow me in My blog,
to get more awesome tutorials like this one.

Please consider supporting me on Ko-fi you help me a lot to
continue building this tutorials! 😁.

🧠 Tutorial: Understand Virtual environments in Python ✅

Daniel Diaz — Sat, 27 Feb 2021 02:08:02 +0000

Why virtual environments?

Virtual environments are a crucial part of making Python projects because they allow you to have separated packages for every project you are working on.

It allows us to code with different versions of our needed packages on every project we are working on, and maintain the packages of our local machine intact.

An example could be managing different projects of Django, with different versions like 2.x or the newer 3.x. This could be just because of preferences, or for a business requirement (Since companies usually use older versions of packages).

The cherry on the cake is that Virtual environments allow developers to share the needed packages for the project they are working on, with a simple file normally called requirements.txt and a short command on the terminal.🚀

So with this brief introduction, let's get into Virtual environments.🤓

Different Virtual environments

There are many virtual environment tools for Python, but I'll talk about the main two.

Take into account that these two are really similar so you can easily use one or another.

Virtualenv

The virtualenv package is a fully powered tool that allows you to create and manage virtual environments in Python.

It is an external package and you can install it with:

pip install virtualenv

Python -m venv

Since Python 3.3, an abstracted version of virtualenv is included as a built-in package, and therefore it doesn't require any installation.

Differences between virtualenv and built-in venv

Virtualenv is a third-party package for managing virtual environments, and it requires installation, while venv is a built-in virtual environment package that is just a subset of virtualenv, and doesn't require installation.

One of the other main differences is that virtualenv supports Python 2.x and Python 3.x, while the built-in method is just available since Python 3.3.

You can find an extensive differentiation here.

Hands on

Now let's use these tools to build what we love, software. 🖥️

Open your terminal, and type the following commands:

To open a terminal in VS code

Click on the top bar Terminal, and click again in New Terminal.

Virtualenv

virtualenv .venv

venv

python3 -m .venv

Where the name .venv, could be any name you want to give to your virtual environment. 💡

Note: Remember that no matter what of these two tools you use the following steps will be always the same, the only thing that changes is the creation of the venv.

Venv structure

The structure of a virtual environment is the following

.
├── bin
│   ├── activate
│   ├── activate.csh
│   ├── activate.fish
│   ├── Activate.ps1
│   ├── easy_install
│   ├── easy_install-3.8
│   ├── pip
│   ├── pip3
│   ├── pip3.8
│   ├── python -> /usr/bin/python
│   └── python3 -> python
├── include
├── lib
│   └── python3.8
│       └── site-packages
│           A lot of packages ...
│
├── lib64 -> lib
└── pyvenv.cfg

131 directories, 1056 files

Where did all this stuff come? 🤯. Well, this looks scary but don't worry.

The bin folder contains all the Python binaries and the activation scripts, we will see later how to activate it.

The lib folder contains all of the modules by itself, for example, if you are looking for a function definition of a library, probably your editor will redirect you to the lib folder, where all the modules are located.

# looking for the "UserCreationForm" class on Django 

.venv/lib/python3.8/site-packages/django/contrib/auth/forms.py

Activating and deactivating virtual environments

Before we continue I'd like to show you another crucial command while working with virtual environments.

pip freeze

pip freeze will print in the console all the packages available to the Python interpreter you are using.

If you do it on your local machine you will get something like this.


╰─λ pip freeze                                                                                  alembic==1.4.3
apparmor==3.0.0
appdirs==1.4.4
asn1crypto==1.4.0
astroid==2.4.2
attrs==20.3.0
autopep8==1.5.4
Babel==2.8.1
bcrypt==3.2.0
Beaker==1.11.0
blinker==1.4
btrfsutil==5.9
CacheControl==0.12.6
cairocffi==1.2.0
catfish==1.4.13
ceph==1.0.0
ceph-volume==1.0.0
cephfs==2.0.0
cephfs-shell==0.0.1
cffi==1.14.3
chardet==3.0.4
click==7.1.2
colorama==0.4.4
configobj==5.0.6
contextlib2==0.6.0.post1
cryptography==3.2.1
etc ...

Those are all the packages that your Python interpreter has installed (and its versions). A pretty huge collection isn't it? 😁.

Now let's activate the virtual environment, called .venv

# .venv is the name of the virtual environment
# Activation for a bash shell in Linux or Mac
source .venv/bin/activate

Activating a venv in other shells

Depending on the shell you use, probably you will use a different command, so take a look at the following table.

In my case since I use fish as my primary shell, I always use activate.fish.

You will notice a little change in your terminal, and it's because you get a little graphic of what environment are you using.

In my case:

After that little parenthesis, run pip freeze again, what do you get?

Exactly, Nothing

You don't get output, just because the virtual env, has a totally isolated Python interpreter instance, with its own libraries installed. 😮

Deactivating Virtual environments

Deactivating an environment is pretty easy, just run

deactivate

You will notice that you don't have the name of the venv in your terminal, and if you run pip freeze, you will get all your installed packages.

Installing packages

Before installing any package be sure to have your venv activated!

Depending on which project you are working on, you will want to install the latest and greatest versions, or a specific version.

To install the latest packages with pip just run:

pip install {package}

For example

# Installing it
pip install requests

# pip freeze
certifi==2020.12.5
chardet==4.0.0
idna==2.10
requests==2.25.1
urllib3==1.26.3

Installing a specific version

To install a specific version of a package, run pip install {package name}=={version number}

# Installing Django 2.2

pip install django==2.2

# pip freeze

Django==2.2
pytz==2021.1
sqlparse==0.4.1

Remember that if you want to check the Django version, just invoke python and run the following code.

╰(.venv)─λ python                                                                             
Python 3.8.6 (default, Sep 30 2020, 04:00:38) 
[GCC 10.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import django
>>> print(django.get_version())
2.2

Installing packages from a text file

To install the packages from a text file just run.

pip install -r {name of the file}.txt
# Usually the file is named requirements.txt

This is extremely useful when you are collaborating in a Python project, and with just a command you get all the necessary stuff to start coding.

To write all your packages in a file run this command.

pip freeze > requirements.txt

This will generate a file named requirements.txt, which content will be the output of pip freeze.

This way is how most specialized servers install the needed packages, to deploy python apps. You give them a file with the requirements and not the virtualenv itself.

Conclusion

Now that you know how to use Virtual environments, you can:

Separate the requirements for each of your projects
Install different versions of packages
Collaborate easily since with just a command or two, you can set up your environment
Don't mess around with the libraries of your machine 😅

Commands shortcut:

# Install virtualenv, and create one
pip install virtualenv
virtualenv {venv name}

# Built in method (Python 3.3 +)
python -m venv {venv name}

# Activating
source {venv name}/bin/activate

# Deactivating
deactivate

# Install from file
pip install -r {file}.txt

# Write a file
pip freeze > requirements.txt

🎯 Tutorial: Deploying a Django app on Heroku

Daniel Diaz — Thu, 18 Feb 2021 04:07:06 +0000

Deploying a Django App

Deploying a Django application to the internet could be difficult, but there are free and dedicated hosting platforms designed for deploy specific frameworks to the Internet.

Heroku may be the perfect choose for those how want a starting free web hosting and sub-domain, and an easy configurable hosting.

Pre-requirements:

You need to have Heroku CLI installed, and be logged in to your account. If you don't have it installed, check out the official docs, Here

Now that you have it installed and you are logged in, you can continue with the Python stuff 🐍.

Necessary packages to deploy on Heroku:

Now make sure to create a virtual environment, my preferred way is virtualenv:
First install it with pip install virtualenv, create a virtual env and create it:

virtualenv venv

#then 
source venv/bin/activate

# Depending on your shell, you could run a different command.

Install Django and your Python development tools:

pip install django

You need some packages to deploy an application to heroku, so let's get into it:

If you just want a command to install most packages you need, copy the line below:

pip install gunicorn django-heroku python-decouple

Let's start with the package that handles most of the server operations: Gunicorn is an easy yet powerful Python HTTP server.

pip install gunicorn

Django Heroku, allow us to don't worry of our settings in the Heroku server.

pip install django-heroku

This package comes with other important packages that facilitates us the deployment in the fields, of static files whitenoise, a postgreSQL adapter psycopg, a package that helps to connect with the Database dj-database-url, and django-heroku itself.

This is almost everything but only a package is left 😁 :

pip install python-decouple

This package helps us to pass python environmental variables on Django, we will se it later I promise😊.

Now let's run pip freeze, you should get something like this:

asgiref==3.3.1
dj-database-url==0.5.0
Django==3.1.6
django-heroku==0.3.1
gunicorn==20.0.4
psycopg2==2.8.6
python-decouple==3.4
pytz==2021.1
sqlparse==0.4.1
whitenoise==5.2.0

Run this command to create a requirements.txt file that Heroku will use to install of the packages needed.

pip freeze > requirements.txt

Create a Procfile

# Run this in the root directory of the app
touch Procfile

Open the file and copy the following file:

web: gunicorn (Your app).wsgi

This tells Heroku, that it must run a web process, with gunicorn as HTTP server and with a wsgi file located in (Your app). Remember to change (Your app) with the name of your project.

Settings.py file

We just installed a lot of stuff, but now it's time to apply all of this in the settings.py file, but first Pro tip.

Pro Tip:

Before continuing modifying the settings file, do the following things:

Duplicate the settings.py file of your project, and rename it as settings_local.py,you will leave that file untouched, and use that configuration, while developing the application in local.

To run the server with the local settings just run the following command:

python manage.py runserver --settings=(Your app).settings_local

Now after that, continue configuring the production environment.

Modifying the settings:

Importing modules

At the top of the file import the following modules:

# Import to serve staticfiles correctly
import os
import django_heroku
import dj_database_url
from decouple import config

Static files

In the MIDDLEWARE variable, set whitenoise middleware below the Security Middleware:

MIDDLEWARE = [
  # 'django.middleware.security.SecurityMiddleware',
  'whitenoise.middleware.WhiteNoiseMiddleware',
  # ...
]

Now go to the bottom of the app, where you could find the following commentaries:

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.1/howto/static-files/

Below paste this code🖥️:

STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
STATIC_URL = '/static/'

STATICFILES_DIRS = [
    os.path.join(BASE_DIR, "static"),
]

STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

Perfect, now our static files should be managed by Whitenoise.

Last step

At the very bottom of the file set the django heroku settings

django_heroku.settings(locals())

That's all of you need to deploy an app to Heroku, good luck!

Create a Pipeline, from a Github Repository

Now click on create a new pipeline:

After that you will be redirected, to the pipeline, click on the add app button in order to create a new app.

Click and add your new app.

From now you will get a fully featured dashboard with the app.

Go to Deploy tab, and in the bottom you will get a button where you can deploy your app. Now click on that button and deploy the main branch.

Extra:

Troubleshooting:

Probably you will get a lot of errors before you can publish your app to the internet, so I'm going to tell you the most common problems and how to fix them.

Static files errors:

One of the most common errors that you will get, may be related with static files.

Error:

-----> $ python manage.py collectstatic --noinput
       Post-processing 'css/owl.carousel.min.css' failed!
       Traceback (most recent call last):
         File "manage.py", line 22, in <module>
           main()
         File "manage.py", line 18, in main
           execute_from_command_line(sys.argv)
         File "/app/.heroku/python/lib/python3.6/site-packages/django/core/management/__init__.py", line 401, in execute_from_command_line
           utility.execute()
         File "/app/.heroku/python/lib/python3.6/site-packages/django/core/management/__init__.py", line 395, in execute
           self.fetch_command(subcommand).run_from_argv(self.argv)
         File "/app/.heroku/python/lib/python3.6/site-packages/django/core/management/base.py", line 330, in run_from_argv
           self.execute(*args, **cmd_options)
         File "/app/.heroku/python/lib/python3.6/site-packages/django/core/management/base.py", line 371, in execute
           output = self.handle(*args, **options)
         File "/app/.heroku/python/lib/python3.6/site-packages/django/contrib/staticfiles/management/commands/collectstatic.py", line 194, in handle
           collected = self.collect()
         File "/app/.heroku/python/lib/python3.6/site-packages/django/contrib/staticfiles/management/commands/collectstatic.py", line 138, in collect
           raise processed
       whitenoise.storage.MissingFileError: The file 'css/owl.video.play.png' could not be found with <whitenoise.storage.CompressedManifestStaticFilesStorage object at 0x7fab586a2710>.
       The CSS file 'css/owl.carousel.min.css' references a file which could not be found:
         css/owl.video.play.png
       Please check the URL references in this CSS file, particularly any
       relative paths which might be pointing to the wrong location.
 !     Error while running '$ python manage.py collectstatic --noinput'.
       See traceback above for details.
       You may need to update application code to resolve this error.
       Or, you can disable collectstatic for this application:
          $ heroku config:set DISABLE_COLLECTSTATIC=1
       https://devcenter.heroku.com/articles/django-assets
 !     Push rejected, failed to compile Python app.
 !     Push failed

As you can see, the error is caused because of a css file pointing to another file that doesn't exist.

Heroku and Django are very sensitive with static files so if a pointing file doesn't exist, an error will occur.

To fix this particular error, set the environment key, DISABLE_COLLECTSTATIC and run locally the collectstatic command.

# Root directory
heroku config:set DISABLE_COLLECTSTATIC=1

# collect static

python manage.py collectstatic

Push the code and deploy the app, this problem should be solved.

Fixing other errors:

To fix an error in production, We will use a logger in Django.

Paste the code below, this will give you a Django logger in production, which you can access with the following command.

# Django logger

# Debugging in heroku live
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': ('%(asctime)s [%(process)d] [%(levelname)s] ' +
                       'pathname=%(pathname)s lineno=%(lineno)s ' +
                       'funcname=%(funcName)s %(message)s'),
            'datefmt': '%Y-%m-%d %H:%M:%S'
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        }
    },
    'handlers': {
        'null': {
            'level': 'DEBUG',
            'class': 'logging.NullHandler',
        },
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'verbose'
        }
    },
    'loggers': {
        'testlogger': {
            'handlers': ['console'],
            'level': 'INFO',
        }
    }
}

DEBUG_PROPAGATE_EXCEPTIONS = True
COMPRESS_ENABLED = os.environ.get('COMPRESS_ENABLED', False)

# Heroku logs
heroku logs --tail

Now you will get a real time logger to debug your application on production.

Thanks for your time hopefully this tutorial will be useful for you 🤗.

Follow me in My blog,
to get more awesome tutorials like this one.
Please consider supporting me on Ko-fi you help me a lot to
continue building this tutorials!.