[pytube api]: https://pytube.io/en/latest/api.html

## Introduction

Those who have been around the python community for a while know just how wide is the ecosystem, there are packages for almost everything, and that is what makes python so convenient. One of them is the `pytube` package, which allows us to easily download audio or video streams for youtube. It's fairly simple to implement and use, today we will be building a simple GUI interface for pytube using the `PySimpleGUI` library.

## Setup

Usually, when working with python we like to have isolated environments as to not fill the whole system with a bunch of packages. We can achieve this using the `venv` command like so:

```bash
//filename:terminal
python -m venv /path/to/new/virtual/environment
```

Know go ahead and install all the dependencies we need, in this case, it would be:

```bash
//filename:terminal
pip install pytube PySimpleGUI
```

Now we are all set to create our GUI.

## The Interface

For this simple demo, we need these features:

1. An URL field for our video url.
2. Download Folder.
3. Option to download between audio and video.

Let's work around the first one. First, we need to import the PySimpleGui object (I am assigning it an alias so its easier to write) and then create our layout, after adding our event loop the result should be the following:

```python
//filename: main.py
import PySimpleGUI as sg

URL_INPUT_KEY = "--url"
LAYOUT = [
    [sg.Text("URL:"), sg.In("", key=URL_INPUT_KEY)],
]

window = sg.Window(title="PyTube Downloader", layout=LAYOUT, margins=(100, 100))
while True:
    event, values = window.read()
    if event == sg.WIN_CLOSED:
        break
```

If you are not used to PySimpleGUI, it allows us to compose our layout in a really straighforward manner, basically, the window is built by rows and colums, each subarray represents a row, and each item a column, here, we have just one row for two items, a label with the text "URL:" and the actual input, we also assign a key to this input in order to access the event later on. After that, we declare our main window, with a title, the layout, and some margins, then run this window in a loop that can only be stopped when pressing the exit button.

after executing `py main.py` we should see something like this:

![Our first window || This is our layout](//images.ctfassets.net/ksv4rmm9mbeg/6By9oCoMBmdoO3lBp9C2MR/c76c2f386395fc8e969f6e0810a0ade4/our_window.png "Our first window")

But well, there are not many things that can be achieved with only this, let's make this layout a little bit more complex:

```python
//filename:main.py
import PySimpleGUI as sg
import os

URL_INPUT_KEY = "--url"
FOLDER_INPUT_KEY = "--folder"
VIDEO_BTN_KEY ="--video"
AUDIO_BTN_KEY = "--audio"

DEFAULT_FOLDER = os.path.join(os.getcwd(), "downloads")

LAYOUT = [
    [sg.Text("Carpeta de guardado:")],
    [sg.In(DEFAULT_FOLDER, enable_events=True, key=FOLDER_INPUT_KEY), sg.FolderBrowse()],
    [sg.Text("URL:"), sg.In("", key=URL_INPUT_KEY)],
    [sg.Button("Video", key=VIDEO_BTN_KEY), sg.VSeparator(), sg.Button("Audio", key=AUDIO_BTN_KEY)],
]

window = sg.Window(title="PyTube Downloader", layout=LAYOUT, margins=(100, 100))
while True:
    event, values = window.read()
    if event == sg.WIN_CLOSED:
        break
```

As you can see, we can expand our layout easily, here we just added the label and input for the folder and two buttons, one for video and the other for audio respectively, each one with a key. There is also a default folder, where the videos are gonna be stored, by default they're going to be stored in a folder called `downloads` in the same location as our main file.

![This is our current layout || This is all for the layout](//images.ctfassets.net/ksv4rmm9mbeg/52Ig27ty4VAMbhMVDNARBp/0ecde4cf3a773b0b7e2b4bc76f260d93/ourwindow2.png "This is our new layout")

## The functionality

Now that we have a nice layout, let's make it functional.

```python
//filename:main.py

import PySimpleGUI as sg
import os
from pytube import YouTube

...constants

LAYOUT = [...]
window = sg.Window(title="PyTube Downloader", layout=LAYOUT, margins=(100, 100))

def download(url, target_dir):
    yt = YouTube(url)
    streams = yt.streams.filter(file_extension="mp4", progressive=True).order_by("resolution").desc()
    streams.first().download(output_path=target_dir)

while True:
    event, values = window.read()

    if event == VIDEO_BTN_KEY:
        url, target_dir = window[URL_INPUT_KEY].get(), window[FOLDER_INPUT_KEY].get()

        download(url, target_dir)
    if event == sg.WIN_CLOSED:
        break
```

Here, we are doing the following:

- Defining a `download` function that takes two arguments, the url and the target directory.
  - Inside here we create an instance of the `Youtube` class from the pytube library.
  - The constructor takes the url of the youtube video, it can also have some configuration parameters, if you're interested you can check out the [Pytube API].
  - Then, we access the stream property, which basically are all the available video formats.
  - We filter those streams, because we only care for those who have the mp4 extension, and are **progressive**
    - Progressive videos are those that have both audio and video, this step is important since youtube uses the DASH streaming technique in some videos to deliver a better experience, the downside for us is that DASH streams only come with the video.
  - After the filtering is done, we order the streams by resolution and then in descendent order since we want the better ones at the top.
  - finally, we take the first stream of the list and download it to our target directory.
- In our loop we then at an if statement that will act as a listener for our video button, inside we take the url and directory values from the window and execute our download function.

If you go ahead and try it out you will see how the video gets downloaded. The only step left is to implement the only-audio option, which shouldn't be a problem.

Let's add an extra argument to our `download` function

```python
//filename: main.py
def download(url, target_dir, audio_only=False):
    yt = YouTube(url)
    streams = None
    if(audio_only):
        streams = yt.streams.filter(audio_only=True)
    else:
        streams = yt.streams.filter(file_extension="mp4", progressive=True).order_by("resolution").desc()
    streams.first().download(output_path=target_dir)
```

Here we are adding an optional argument called `audio_only`, if enabled, we only search for the audio streams inside the video.

And then in our event loop:

```python
//filename: main.py
while True:
    event, values = window.read()

    if event == VIDEO_BTN_KEY:
        url, target_dir = window[URL_INPUT_KEY].get(), window[FOLDER_INPUT_KEY].get()
        download(url, target_dir)
    if event == AUDIO_BTN_KEY:
        url, target_dir = window[URL_INPUT_KEY].get(), window[FOLDER_INPUT_KEY].get()
        download(url, target_dir, True)
    if event == sg.WIN_CLOSED:
        break
```

And that's about it! You can go ahead and add more functionalities, like a progress bar for the videos, a regex that checks if both the url and directory are correct, a filename field, etc.

## Troubleshooting

If you had a `KeyError: 'streamingData'` when downloading the video, that could mean that the pytube library is not up-to-date, you can fix it by fetching it right from the git repository, like so:

```bash
//filename: terminal
python -m pip install git+https://github.com/nficano/pytube
```

## Conclusions

We learned how to use the pytube library along the PySimpleGUI to create a quick and functional youtube video downloader, I hope you found this article helpful, see you in the next one!

## Related links

- Pytube: https://pytube.io/en/latest/index.html
- PySimpleGUI: https://www.pysimplegui.org/en/latest/


Python allows us to quickly set up all kind of apps. In this occasion, we'll see how to create a desktop application for youtube video downloading using the pytube library.

Let's make a Youtube video downloader with Python and Pytube

Creating a blog is the milestone for a lot of developers, and there's a lot of ways to get the job done. Let's see how to it the NextJS route!

How to Create a Blog with NextJS, TailwindCSS and Markdown


There's a lot of algorithms that develop machine learning powered systems, without doubt one of the best out there is the Decision Tree algorithm, but how does it work behind the scenes?
## What is the Decision Tree Algorithm

Like its peers, is a technique that allows us to predict a value given certain data that may be connected. It's used in data mining, predictive modeling and classification. It works like a flowchart, where we begin from the root node, going through the decision nodes and finally reaching an output in one of the leaf nodes.
![Decision Tree Example](//images.ctfassets.net/ksv4rmm9mbeg/3qrRHzLAfYnsIGodDp5ii9/0b0a72ece78150ca53577022c797a82c/DecisionTreeExample.jpg "Decision tree Example")

Like basically all of its siblings, the decision tree can be divided in two types

* Categorical: Let's say we need to find out if a email is spam or not according to the email contents, title, and sender. The desired prediction is categorical (spam or not) so what we need is a categorical tree.
* Continuous: But what if what we need is to predict the temperature in a room? or the rain probability? In these cases what we need is a continuous tree.

## How to create a Decision Tree

There are several ways to create decision trees, in this example we will use the ID3 algorithm, which receives 3 inputs, the samples, the target attribute and all the other attributes, giving us the final decision tree.
We will use the previous email case to create a categorical tree. Like we discussed earlier, our attributes are gonna be if the email contains shady links, a spam like title and if the sender has a weird email account, with **is it spam?** being our target attribute. The first step is to collect data to create the tree from, like the following:

<style>
.first-dataset tbody tr:nth-child(1) td:last-of-type, .first-dataset tr:nth-child(2) td:last-of-type, .first-dataset tr:nth-child(3) td:last-of-type, .first-dataset tr:nth-child(6) td:last-of-type, .first-dataset tr:nth-child(9) td:last-of-type {
  background-color: #37AA78!important;
  color: #f4f4f4!important;
  font-weight: bold;
}
.first-dataset tr:nth-child(4) td:last-of-type, .first-dataset tr:nth-child(5) td:last-of-type, .first-dataset tr:nth-child(7) td:last-of-type, .first-dataset tr:nth-child(8) td:last-of-type{
  background-color: #AA3737!important;
  color: #f4f4f4!important;
  font-weight: bold;
}
</style>
<div class="first-dataset">

| Shady content? | Weird title? | Weird sender email? | Is it spam? |
| -------------- | ------------ | ------------------- | ----------- |
| Yes            | No           | Yes                 | Yes         |
| No             | Yes          | Yes                 | Yes         |
| No             | No           | Yes                 | Yes         |
| No             | Yes          | No                  | No          |
| No             | No           | No                  | No          |
| Yes            | No           | Yes                 | Yes         |
| No             | Yes          | No                  | No          |
| No             | No           | No                  | No          |
| Yes            | No           | No                  | Yes         |

</div>

## The math

### Entropy

Now that we have everything we need, we can begin with the math. First we need to calculate the entropy of the data, which is only a fancy way to call the diversity of the data. The higher the entropy, the more random is gonna be the data, and the opposite is true. The entropy of a dataset is given by this formula:

$$H(\text{samples})=-\bigg(\sum_{v} \frac{\text{Samples}(v)}{\text{Total Samples}}\log_2\frac{\text{Samples}(v)}{\text{Total Samples}}\bigg)$$

These formula refers to the target sample, we have to get every value that v can have (in this case if its spam or not) and apply the formula. Simplified, it would look somewhat like:

$$ -(\frac{5}{9}\log_2(\frac{5}{9}) + \frac{4}{9}\log_2(\frac{4}{9}))$$

Where the 5 represents the number of "yes" or true values, the 4 represent the noes, and 9 the total of samples.

The previous formula gives us an entropy of $\bold{0.94029}$.

Let'ts obtain the information gain for every attribute, except spam. The information gain let us know how valuable an attribute is when determining the outcome, the higher, the better. The following formula let us know the information gain for each attribute A:

$$IG(\text{samples}, A) = H(\text{samples}) - \sum_{t\in T}\frac{t}{\text{samples}}\cdot H(t)$$

Next we need to calculate the IG for each attribute:

### First iteration

---

#### Content

$$
    H(content, Yes) = -(\frac{3}{3}\log_2(\frac{3}{3}) + 0) = 0
$$

$$
    H(content, No) = -(\frac{2}{6}\log_2(\frac{2}{6}) + \frac{4}{6}\log_2(\frac{4}{6})) = 0.9182
$$

$$
    IG(content) = H(\text{samples}) - (\frac{3}{9}\cdot H(content, Yes) + \frac{6}{9}\cdot H(content, No)) = 0.3280
$$

#### Title

$$
    H(title, Yes) = -(\frac{1}{3}\log_2(\frac{1}{3}) + \frac{2}{3}\log_2(\frac{2}{3})) = 0.9182
$$

$$
    H(title, No) = -(\frac{4}{6}\log_2(\frac{4}{6}) + \frac{2}{6}\log_2(\frac{2}{6})) = 0.9182
$$

$$
    IG(title) = H(\text{samples}) - (\frac{3}{9}\cdot H(title, Yes) + \frac{6}{9}\cdot H(title, No)) = 0.022
$$

#### Sender

$$
    H(sender, Yes) = -(\frac{4}{4}\log_2(\frac{4}{4}) + 0) = 0
$$

$$
    H(sender, No) = -(\frac{5}{6}\log_2(\frac{5}{6}) +\frac{1}{6}\log_2(\frac{1}{6})) = 0.6500
$$

$$
    IG(sender) = H(\text{samples}) - (\frac{4}{9}\cdot H(sender, Yes) + \frac{6}{9}\cdot H(sender, No)) = 0.506
$$

Now we compare the information gain from each attribute and establish the bigger one as our root node, in this case sender is the one with the higher IG (0.506), and because the entropy of the "yes" was 0, we put it as a leaf node. So far this is our tree:

![First tree](//images.ctfassets.net/ksv4rmm9mbeg/317NDfrfgVJl4xVc5CtOnT/fdb2984e370858f3291fbe43673ef111/tree1.jpg "First tree")

Now we have to continue developing the tree until we find a decision node that only has leaf nodes attached. But don't worry, since we took care of the "sender" attribute, we only have to work with content and title, and since yes resulted in a leaf node, we only have to use the tuples where sender is "no", this means we end up with the next dataset:

<style>
.second-dataset tr:nth-child(5) td:last-of-type {
  background-color: #37AA78!important;
  color: #f4f4f4!important;
  font-weight: bold;
}
.second-dataset tbody tr:nth-child(1) td:last-of-type, .second-dataset tr:nth-child(2) td:last-of-type, .second-dataset tr:nth-child(3) td:last-of-type, .second-dataset tr:nth-child(4) td:last-of-type{
  background-color: #AA3737!important;
  color: #f4f4f4!important;
  font-weight: bold;
}
</style>

<div class="second-dataset">

| Shady content? | Weird title? | Weird sender email? | Is it spam? |
| -------------- | ------------ | ------------------- | ----------- |
| No             | Yes          | No                  | No          |
| No             | No           | No                  | No          |
| No             | Yes          | No                  | No          |
| No             | No           | No                  | No          |
| Yes            | No           | No                  | Yes         |

</div>

Now all that's left is to calculate the IG of Shady content and the weird title, plus the entropy of sender=no.

### Second iteration

---

#### Entropy

$$
    H(sender=no) = -(\frac{4}{5}\log_2(\frac{4}{5}) + \frac{1}{5}\log_2(\frac{1}{5})) = 0.7219
$$

#### Content

$$
    H(content, Yes) = -(\frac{4}{4}\log_2(\frac{4}{4}) + 0) = 0
$$

$$
    H(content, No) = -(\frac{1}{1}\log2(\frac{1}{1}) + 0) = 0
$$

$$
    IG(content) = H(\text{sender=no}) - (\frac{4}{5}\cdot H(content, Yes) + \frac{1}{5}\cdot H(content, No)) = 0.7219
$$

#### Title

$$
    H(title, Yes) = -(0 + \frac{2}{2}\log2(\frac{2}{2})) = 0
$$

$$
    H(title, No) = -(\frac{1}{3}\log_2(\frac{1}{3}) + \frac{2}{3}\log_2(\frac{2}{3})) = 0.8112
$$

$$
    IG(title) = H(\text{sender=no}) - (\frac{2}{5}\cdot H(title, Yes) + \frac{3}{5}\cdot H(title, No)) = 0.2351
$$

As we can see, content is now the attribute that gives us the most IG, and since both yes and no gave us 0 entropy we set them as leaf nodes, and that's it! Our tree ends up like this:

![Final tree](//images.ctfassets.net/ksv4rmm9mbeg/33asPSk7F1igBvTlfcSoc/167e210069029d54e72ca3e5b6acf4a8/finalTree.jpg "Final tree")

### Testing

We can include new data to see how well the tree behave, try classifying the next tuple:

<style>
    .test-dataset tbody tr:nth-child(1) td:last-of-type{
          background-color: #37AA78!important;
  color: #f4f4f4!important;
  font-weight: bold;
    }
</style>
<div class="test-dataset">

| Shady content? | Weird title? | Weird sender email? | Is it spam? |
| -------------- | ------------ | ------------------- | ----------- |
| Yes            | No           | No                  | Yes         |

</div>

## Conclusion

We learned how to create a decision tree using the ID3 algorithm, and the math behind it. Even though the decision tree can be helpful, there are a lot of algorithms better at classifiying data, like the random forest, nonetheless, it's important to know how this algorithms behave in order to gain a better understanding of machine learning.


The decision tree algorithm is one of the most used techniques when it comes to Machine Learning, I'll show you in depth how it works in an understandable way!

Let's make a Youtube video downloader with Python and Pytube

How to Create a Blog with NextJS, TailwindCSS and Markdown

The Decision Tree Algorithm