DEV Community: Fahmi Nurfikri

How to Install Python Pyenv on macOS

Fahmi Nurfikri — Mon, 02 Oct 2023 13:00:00 +0000

One of the hardest processes to learning Python for beginners is installing Python. Sometimes it was a version problem, the machine doesn’t recognize commands, etc.

I was included with people who deal with those problems. My solution at that time was just to install the Anaconda package. But since the Anaconda package size is too big for what I need, I feel that method is too overkill for me.

After searching for a while, I got the solution to this problem, and the solution is Pyenv.

What is Pyenv?

Basically, Pyenv is a tool to simplify installation and version changing in Python. It helps developers quickly install or change the Python version without needing to change the whole system.

In this post, I will show you how to install Pyenv and manage the Python version.

Installing Homebrew

If Homebrew hasn’t been installed on your computer, run this command in the terminal.

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

It will take a while. After the installation process is done, it will show you a message like this.

For the next step, we will need to copy the text highlighted above to the terminal.

echo '# Set PATH, MANPATH, etc., for Homebrew.' >> /Users/fahminurfikri/.zprofile
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> /Users/fahminurfikri/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

When the process is finished, restart the terminal, and Homebrew is already installed on your computer.

Installing PyEnv using Homebrew

Once Homebrew is installed, we can use it to install Pyenv. This can be done by running the command below:

brew install pyenv

Once the installation progress is finished, you can check it by using the command pyenv versions on your terminal. The output would be like this.

If the output doesn’t show an error, then we can continue to the Python installation. To see the available Python version, you can use this command.

pyenv install --list

For example, I will install Python 3.9.15. So the command will be like this.

pyenv install 3.9.15

Don’t worry if your terminal doesn’t return anything, the process takes a while. Maybe you can leave it for a while to make coffee or something.

If the installation is already done, you can verify if the Python version is already installed, you can use the:

pyenv versions

And the result will look like this.

* system (set by /home/user/.pyenv/version)
  3.9.15

The * means that the system is the default Python version. To set Python 3.9.15 as the default Python, use the command:

pyenv global 3.9.15

After that, check the Python version.

python --version  # or python -V

If the Python version is 3.9.15 or whatever Python version you install, then the Python installation is a success. If you want to add another Python version, you can just use pyenv install <version> and if you want to change the Python version, you can just use pyenv global <version>.

How to Install Python using Pyenv on Ubuntu 20.04

Fahmi Nurfikri — Sat, 30 Sep 2023 13:00:00 +0000

When it comes to Python, did you ever find a problem installing or changing the Python version? If yes, then we’re the same. I always have a problem when it comes to changing the Python version and my only solution at that time is just uninstalling Python and re-installing the version that I need.

After dealing with that problem for a long time, I finally found the tools to manage the Python version, named Pyenv.

What is Pyenv?

Basically, Pyenv is a tool to simplify installation and version changing in Python. It helps developers quickly install or change the Python version without needing to change the whole system.

In this post, I will show you how to install pyenv and manage the Python version.

Install Pyenv

To start the installation process, it’s a good idea to update the system packages. Open the terminal and write the command below.

apt update -y

After that, let’s install all Pyenv dependencies.

apt install -y make build-essential libssl-dev zlib1g-dev \
> libbz2-dev libreadline-dev libsqlite3-dev wget curl llvm libncurses5-dev\
> libncursesw5-dev xz-utils tk-dev libffi-dev liblzma-dev python-openssl\
> git

After that, we will install the latest version on Pyenv. So, we will need to clone from the Pyenv repository.

git clone https://github.com/pyenv/pyenv.git ~/.pyenv

For the last step, we must add pyenv to our path so that the pyenv command is recognized globally.

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bashrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(pyenv init --path)"' >> ~/.bashrc

Finally, to start using pyenv, restart the shell by running:

exec "$SHELL"

Install Python

To check whether pyenv is already installed on our machine, we can use this command.

pyenv --version

In mine, the response is pyenv 2.3.6–13-g4c261e6e, if you do not see a result similar to this, then maybe there is an error in your installation.

To see the available Python version, you can use this command.

pyenv install --list

For example, I will install Python 3.9.15. So the command will be like this.

pyenv install 3.9.15

Don’t worry if your terminal doesn’t return anything, the process takes a while. Maybe you can leave it for a while to make coffee or something.

If the installation is already done, you can verify if the Python version is already installed, you can use the:

pyenv versions

And the result will look like this.

* system (set by /home/user/.pyenv/version)
  3.9.15

The * means that the system is the default Python version. To set Python 3.9.15 as the default Python, use the command:

pyenv global 3.9.15

After that, check the Python version.

python --version  # or python -V

Creating Simple FontArt using Python

Fahmi Nurfikri — Thu, 28 Sep 2023 09:06:25 +0000

Python is a programming language that is widely used in the world. One of the reasons is that Python is a language that is easy to learn and can be used for many platforms.

After using Python for a long time, maybe we feel bored with the appearance of the output that is just like that. Now, in this post, I will give a few tips on how to add FontArt to the Python output display.

The method is quite easy, the first thing we have to do is install the PyFiglet library. PyFiglet converts ASCII text to ASCII art font.

pip install pyfiglet

After the installation is complete, then open the code editor and type the following code.

import pyfiglet
result = pyfiglet.figlet_format('Miloo Project')
print(result)

The result of the code is like this.

In addition, we can also change the displayed font, by adding a font parameter to the .figlet_format function.

import pyfiglet
result = pyfiglet.figlet_format('Miloo Project', font='banner3-D')
print(result)

And the result will be like this.

You can get the type of font itself on this page.

You can find the complete code on GitHub.

That’s all for this post, if you have any questions, please write in the comments. Thank you.

Web Scraping News with 4 lines using Python

Fahmi Nurfikri — Wed, 27 Sep 2023 00:06:09 +0000

In this article, I will show you how to collect and scrap news from various sources. Therefore, instead of spending a long time writing scraping code for each website, we will use newspaper3k to automatically extract structured information.

Let’s get started, the first step is to install the package that will be used, namely newspaper3k using pip. Open your terminal (Linux / macOS) or command prompt (windows) and type:

pip install newspaper3k

After installation is completed, open your code editor and import the package with the following code

from newspaper import Article

In this post, I will scrape the news from The New York Times entitled "A Lifetime of Running with Ahmaud Arbery Ends With a Text: ‘We Lost Maud’".

Next, enter the link to be scrapped

article = Article('https://www.nytimes.com/2020/05/10/us/ahmaud-arbery-georgia.html’)

You have the choice to determine the language used. Even so, the newspaper can detect and extract language quite well. If no specific language is given, the newspaper will detect the language automatically.

But, if you want to use a specific language, change the code to be like.

article = Article('https://www.nytimes.com/2020/05/10/us/ahmaud-arbery-georgia.html', 'en') # English

Then parse the article with the following code

article.download()
article.parse()

Now everything is set. We can start using several methods to extract information, starting with the article authors.

print(article.authors)
# it will show ['Richard Fausset']

Next, we will get the date that the article was published.

print(article.publish_date)
# it will show datetime.datetime(2020, 5, 10, 0, 0)

Get full text from the article.

print(article.text)
# it will show ‘Mr. Baker was with Mr. Arbery’s family at his grave site . . .’

You can also get image links from articles.

print(article.top_image)
# it will show'https://static01.nyt.com/images/2020/05/10/us/10georgia-arbery-1/10georgia-arbery-1-facebookJumbo-v2.jpg'

In addition, the newspaper3k also provides methods for simple text processing, such as to get keywords and summarization. First, initialize using .nlp() method.

article.nlp()

Get the keywords.

print(article.keywords)
# it will show
['running',
 'world',
 'needed',
 'arbery',
 'lifetime',
 'site',
 'baker',
 'text',
 'wished',
 'maud',
 'arberys',
 'lost',
 'pandemic',
 'upended',
 'ends',
 'ahmaud',
 'unsure',
 'mr']

And next is to summarize the news, but this feature is limited to only a few languages as explained in the documentation.

print(article.summary)
# it will show 'Mr. Baker was with Mr. Arbery’s family at his grave site.\nIt was Mr. Arbery’s birthday.\nA pandemic had upended the world, and Mr. Baker felt adrift.\nSometimes he wished to be called a musician, and sometimes he did not.\nHe was unsure what he would become or how he would get there.'

If you want to see the full code, you can see it on my Github.

The conclusion of this post is that we can scrape news with various sources in Python quite easily using the newspaper3k package, compared to if we have to spend a long time writing scraping code for each website. By using this package, we can retrieve basic information needed such as authors, publish date, text, and images from news. There are also methods for getting keywords and summaries of news. And most importantly newspaper3k can be used to do news scraping in various languages.

Django-Ninja: Built-in Django, Feels like FastAPI

Fahmi Nurfikri — Sun, 24 Sep 2023 03:04:03 +0000

Django is the web framework most widely used by Python developers. Django offers a very powerful toolkit for creating web applications, making it easier for developers to create complex web applications effectively and efficiently.

However, Django has weaknesses. When it comes to performance, flexibility of project structure, compatibility with other libraries, or creating microservices, Django is not the main choice, and usually Python developers will choose to use FastAPI. Why?

FastAPI excels at building APIs and real-time applications, utilizing asynchronous programming and type hints, while Django, with its full-stack framework features, is better suited to traditional web applications with admin panels, user authentication, and more.

But, what if you could leverage the benefits of Django and get performance similar to FastAPI? I will introduce you to Django-ninja, a game-changing framework that seamlessly bridges this gap, offering web developers a versatile tool to build high-performance web APIs without compromising the power and flexibility of Django. For me, it was a combination between Django and FastAPI.

So, what is Django-ninja?

Django Ninja is a Django API framework that is heavily influenced by FastAPI, a popular Python web framework. It offers a variety of features, many of which are inspired by FastAPI, such as support for asynchronous programming, type-hinted and schema-based request and response validation, automatic API documentation, and a simple, intuitive, and Pythonic way to define REST API routes.

Django Ninja provides an alternative to Django REST Framework (DRF), which is another popular Django API framework. DRF is a powerful tool, but Django Ninja is a more lightweight and appealing alternative that may be a better fit for some Django projects.

For more information, you can visit their Homepage.

In this post, I will show you how to create a simple CRUD API with Django-ninja and see how the code is just like FastAPI. To create a simple CRUD API with Django Ninja, we can follow these steps:

Create Django Project

First, I start by creating a folder called django_ninja_example and installing Django Ninja dependencies.

pip install django-ninja

And then, create a new Django project inside the folder django_ninja_example.

django-admin startproject notes_app

Create Django App

After that, we will need to create our Django app. We will create our app inside the folder notes_app. First, we need to create folder notes inside the notes_app, as follows.

mkdir notes_app/notes

Then, create the Django app using

django-admin startapp notes notes_app/notes

If you succeed, the folder structure will be like this.

django_ninja_example
├── manage.py
└── notes_app
    ├── __init__.py
    ├── asgi.py
    ├── notes
    │   ├── __init__.py
    │   ├── admin.py
    │   ├── apps.py
    │   ├── migrations
    │   │   └── __init__.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    ├── settings.py
    ├── urls.py
    └── wsgi.py

Create a Django model

First, we need to change the notes_app/notes/apps.py into this.

class PagesConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'notes_app.notes'

And also we need to add our app into INSTALLED_APPS in notes_app/settings.py.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'notes_app.notes' # this is what we need to add
]

Finally, we can start to create our model. We will create model Notes. Open notes_app/notes/apps.py and write this code.

class Notes(models.Model):
    title = models.CharField(max_length=30)
    text = models.TextField()

Next, we will create the Schema. In traditional Django, we call it serializer. The schema structure is like what we found in FastAPI, this is because they both use Pydantic.

Create a file named schemas.py in notes_app/notes and write this code.

from ninja import Schema, ModelSchema
from notes_app.notes.models import Notes

class NoteResponseSchema(Schema):
    id: int
    title: "str"

class NoteDetailResponseSchema(ModelSchema):
    class Config:
        model = Notes
        model_fields = "__all__"

class NoteInputSchema(Schema):
    title: "str"
    text: str

In the code above I create three schemas. The first schema is used to get a note list, the second one is when get a single note, and the last one is used when we want to create or edit a note.

Creating Route

For the next, let's create the API route. We will create a simple CRUD API. Let's create a file named api.py in the folder notes_app/notes, and write the code below.

from typing import List
from ninja import Router

from notes_app.notes.models import Notes
from notes_app.notes.schemas import (
    NoteResponseSchema,
    NoteDetailResponseSchema,
    NoteInputSchema,
)

router = Router()

@router.get("", response=List[NoteResponseSchema])
def view_list_notes(request):
    return Notes.objects.all()

@router.get("/{notes_id}", response=NoteDetailResponseSchema)
def view_note(request, notes_id: int):
    return Notes.objects.get(id=notes_id)

@router.post("", response=NoteDetailResponseSchema)
def create_note(request, payload: NoteInputSchema):
    note = Notes.objects.create(title=payload.title, text=payload.text)
    return note

@router.put("/{notes_id}", response=NoteDetailResponseSchema)
def edit_note(request, notes_id: int, payload: NoteInputSchema):
    note = Notes.objects.get(id=notes_id)
    note.title = payload.title
    note.text = payload.text
    note.save()
    return note

@router.delete("/{notes_id}")
def delete_note(request, notes_id: int):
    note = Notes.objects.get(id=notes_id)
    note.delete()
    return

As you can see it is very similar to FastAPI, the difference is it uses the Django ORM which for me personally is easier to use instead of using SQLalchemy or SQLModel.

You can also add pagination to the notes list by only using the pagination decorator. Here's an example:

from ninja.pagination import paginate

@router.get("", response=List[NoteResponseSchema])
@paginate
def view_list_notes(request):
    return Notes.objects.all()

You can also use an async function in Django-ninja. If you using the Django version below 4.1, you need to use the sync_to_async() adapter to use an async function. For example:

from asgiref.sync import sync_to_async

@router.get("/{notes_id}", response=NoteDetailResponseSchema)
async def view_note(request, notes_id: int):
    return await sync_to_async(Notes.objects.get)(id=notes_id)

@router.post("", response=NoteDetailResponseSchema)
async def create_note(request, payload: NoteInputSchema):
    note = await sync_to_async(Notes.objects.create)(
        title=payload.title, text=payload.text
    )
    return note

For a QuerySet result, we need to use an evaluation list. For example:

@router.get("", response=List[NoteResponseSchema])
async def view_list_notes(request):
    return await sync_to_async(list)(Notes.objects.all())

Django 4.1 and above come with asynchronous versions of ORM operations, so we don't need to use sync_to_async anymore. We just need to add a prefix to the existing synchronous operation except for the QuerySet result.

Here's an example of a simple CRUD API with asynchronous operation.

from typing import List
from ninja import Router
from ninja.pagination import paginate

from notes_app.notes.schemas import (
    NoteResponseSchema,
    NoteDetailResponseSchema,
    NoteInputSchema,
)
from notes_app.notes.models import Notes

router = Router()

@router.get("", response=List[NoteResponseSchema])
async def view_list_notes(request):
    all_blogs = [note async for note in Notes.objects.all()]
    return all_blogs

@router.get("/{notes_id}", response=NoteDetailResponseSchema)
async def view_note(request, notes_id: int):
    return await Notes.objects.aget(id=notes_id)

@router.post("", response=NoteDetailResponseSchema)
async def create_note(request, payload: NoteInputSchema):
    note = await Notes.objects.acreate(
        title=payload.title, text=payload.text
    )
    return note

@router.put("/{notes_id}", response=NoteDetailResponseSchema)
async def edit_note(request, notes_id: int, payload: NoteInputSchema):
    note = await Notes.objects.aget(id=notes_id)
    note.title = payload.title
    note.text = payload.text
    await note.asave()
    return note

@router.delete("/{notes_id}")
async def delete_note(request, notes_id: int):
    note = await Notes.objects.aget(id=notes_id)
    await note.adelete()
    return

If you want to add pagination to the async route, it not gonna be easy but that is possible. The Django-ninja version that I currently use is 0.22.2, which still does not support async pagination. So I'm using the code that was created by chrismaille.

I created a file for the async pagination notes_app/utils/async_pagination.py and put the code there. So I'm just adding the async pagination function to the view_list_notes.

from notes_app.utils.async_pagination import apaginate

@router.get("", response=List[NoteResponseSchema])
@apaginate
async def view_list_notes(request):
    all_blogs = [note async for note in Notes.objects.all()]
    return all_blogs

We already created the notes router. All we need is to add the notes router to the global router. Let's create file api.py in the notes_app folder and write this code.

from ninja import NinjaAPI
from notes_app.notes.api import router as notes_router

api = NinjaAPI()
api.add_router("notes", notes_router)
You also need to add a Django-ninja router to urls.py.
from notes_app.api import api

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

Now, everything is ready. You just need to register the notes model to the database. Write this command in the Terminal.

python manage.py makemigrations
python manage.py migrate

Finally, run the code.

python manage.py runserver

If the result is like the image below, then your code is successfully running with no problem.

Then open the http://127.0.0.1/8000/api/docs or whatever host or port you use. If you open the Swagger page then you are good.

So that's it. That is how you build Django-ninja CRUD API. If you want to read more about the Django-ninja, please read the Django-ninja documentation here.

In conclusion, Django-ninja is a powerful and versatile Python web framework for building REST APIs. It is designed to be fast, simple, and easy to use, while still providing all the features you need to build robust and scalable APIs. It has the Django system and code styling like FastAPI, it was like these two combined.

However, it also has disadvantages. Compared to the other Python frameworks, Django-ninja has a smaller community and ecosystem. It means that there are fewer third-party libraries and resources available for Django Ninja, like when we want to create an asynchronous pagination. Moreover, Django-ninja is still under development, so maybe there is still a bug or missing feature.

That is my conclusion about Django-ninja, if you have any questions or opinions regarding Django-ninja or any other, feel free to write in the comments.

Create Word Cloud into any Shape you want using Python

Fahmi Nurfikri — Wed, 06 Sep 2023 10:15:09 +0000

Data visualization (such as charts, graphs, infographics, etc.) gives businesses a value to communicate important information, but what if your data is text-based? If you want the stunning visualization format to highlight important textual data points, then using a word cloud.

If you are not familiar with word cloud, it is a picture consisting of a group of words where the size of each word represents frequency or importance. The bigger and bolder the word appears, the more often it’s mentioned within a given text and the more important it is. Word clouds are easy to read and simple to understand. The key words stand out to the reader and are visually appealing to the audience.

However, you might be bored seeing the simple form of the word cloud. What if I told you that WordCloud can also be custom made to our liking. In this article, we explore how to generate a word cloud in python in any shape that you desire. So, let’s get started.

If you want to see the full code of this article, please visit my github. The first step is to install the package that will be used, namely wordcloud. Open your terminal (Linux / macOS) or command prompt (windows) and type:

$ pip install wordcloud

We will start by doing web scraping on an article on the internet. If you are not familiar with web scraping, I suggest you read my previous article entitled Web Scraping News with 4 lines using Python.

In this post, I will scrape the news from Wikipedia entitled ‘Ice Cream’.

from newspaper import Article
article = Article('https://en.wikipedia.org/wiki/Ice_cream')
article.download()
article.parse()

And we only take the text of the article, which is:

article.text

Simple Word Cloud

We will start by making a simple word cloud. The first step to take is to import dependencies that we will use.

from wordcloud import WordCloud
import matplotlib.pyplot as plt

Here we use the wordcloud library and matplotlib. The wordcloud library is used to generate the word cloud, while matplotlib is used to display the results of the word cloud. After that, we call the word cloud function and display the word cloud.

wc = WordCloud()
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And this is the result of the simple word cloud that we created.

In addition, the wordcloud function has parameters, including:

background_color = Color of background
max_words = The maximum number of unique words used
stopwords = stopword list
max_font_size = Maximum font size
random_state = To ensure that random numbers are generated in the
same order, so the results will be the same even if generated several times
width = width size of the output
height = height size of the output

Let’s try using the parameters above. First, let’s import the stopword provided by the wordcloud library

from wordcloud import STOPWORDS
Then we enter the following code

wc = WordCloud(background_color="white", max_words=2000,
               stopwords=STOPWORDS, max_font_size=256,
               random_state=42, width=500, height=500)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And this is the result.

Add Custom Font

We can also change the font used. You can download fonts from the site dafont for personal use. Next, enter the path of the font into the parameters.

font_path = 'path/to/font'
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path, 
               background_color="white", max_words=2000,
               max_font_size=256, random_state=42,
               width=500, height=500)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And this is the result

Add Custom Mask

Next we will add a mask for the word cloud. Keep in mind the background of the image used must be white, otherwise, the system will consider the background as an object. In addition, the background cannot be transparent, because transparent colors will be considered black. I will use the following image as a mask.

We need to add some dependencies to load the image.

from PIL import Image
import numpy as np

Next, enter the path of the font into the parameters.

mask = np.array(Image.open('path/to/image'))
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
               mask=mask, background_color="white",
               max_words=2000, max_font_size=256,
               random_state=42, width=mask.shape[1],
               height=mask.shape[0])
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And this is the result.

Adjust Colors

We can also adjust the colors used in the word cloud. Basically we are free to determine the color we will use, but in this article I will discuss the fairly commonly used. We will use just one color. But, we must define the function to be used.

def one_color_func(word=None, font_size=None, 
                   position=None, orientation=None, 
                   font_path=None, random_state=None):
    h = 160 # 0 - 360
    s = 100 # 0 - 100
    l = 50 # 0 - 100
return "hsl({}, {}%, {}%)".format(h, s, l)

The color format used is the HSL format (hue, saturation, lightness). For more details, please visit HSL Color Picker to find out more about the colors used. Then to form the word cloud, all we have to do is add the functions that we have created to the word cloud function.

wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
               mask=mask, background_color="white",
               max_words=2000, max_font_size=256,
               random_state=42, width=mask.shape[1],
               height=mask.shape[0], color_func=one_color_func)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And the image will appear like this.

Apart from that, we can also produce similar colors by randomizing within a certain range. I will add a random function to lightness to adjust the brightness of the colors.

def similar_color_func(word=None, font_size=None,
                       position=None, orientation=None,
                       font_path=None, random_state=None):
    h = 40 # 0 - 360
    s = 100 # 0 - 100
    l = random_state.randint(30, 70) # 0 - 100
return "hsl({}, {}%, {}%)".format(h, s, l)

Then, the same as before. Enter the function into the wordcloud function.

wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
               mask=mask, background_color="white",
               max_words=2000, max_font_size=256,
               random_state=42, width=mask.shape[1],
               height=mask.shape[0], color_func=similar_color_func)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And the result will be like this.

In addition, we can define many colors that we will use. As an example.

def multi_color_func(word=None, font_size=None,
                     position=None, orientation=None,
                     font_path=None, random_state=None):
    colors = [[4, 77, 82],
              [25, 74, 85],
              [82, 43, 84],
              [158, 48, 79]]
    rand = random_state.randint(0, len(colors) - 1)
return "hsl({}, {}%, {}%)".format(colors[rand][0], colors[rand][1], colors[rand][2])

And add the function into the wordcloud function.

wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
               mask=mask, background_color="white",
               max_words=2000, max_font_size=256,
               random_state=42, width=mask.shape[1],
               height=mask.shape[0], color_func=multi_color_func)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

And the result be like this.

And last but not least, generate color based on the mask. We will need the functions provided by the wordcloud library.

from wordcloud import ImageColorGenerator

Then add the masking colors and add the function into the wordcloud function.

mask_colors = ImageColorGenerator(mask)
wc = WordCloud(stopwords=STOPWORDS, font_path=font_path,
               mask=mask, background_color="white",
               max_words=2000, max_font_size=256,
               random_state=42, width=mask.shape[1],
               height=mask.shape[0], color_func=mask_colors)
wc.generate(article.text)
plt.imshow(wc, interpolation="bilinear")
plt.axis('off')
plt.show()

This is the final result.

As we can see, the color of the word cloud follows the color of the original image.

So for this post, I hope you get new knowledge from what I have said. If you have other opinions, please write in the comments. In the future, I will analyze the usage of this word cloud for text analysis.

FastAPI has Ruined Flask Forever for Me

Fahmi Nurfikri — Tue, 05 Sep 2023 12:59:44 +0000

What do you like best about being a data scientist? It’s definitely modeling and fine-tuning for optimal results. But what does it mean to be a good model if it’s never used or never deployed?

To produce a machine learning model, the typical approach is to wrap it in a REST API and use it as a microservice. One of the most widely used frameworks for creating APIs is Flask.

The main reason Flask is widely used is its simplicity. In general, we only use the API to model predictions, so we don’t need a complex architecture (example: Django). Another reason is that Flask is written in Python, which is the language used to do machine learning modeling in general, so we are familiar with it.

However, if you want to create a REST API with clear, static, inputs that are validated, you must include several different packages from several third parties that do not cooperate with each other. And you have to create custom code to get everything running.

This is what caused me to look for alternatives for my needs, where finally I found a framework called FastAPI and it became my new favorite framework. Here are the reasons why I like to use FastAPI.

Documentation

The first thing I notice from FastAPI is the documentation. FastAPI has very extensive documentation and rich examples, which makes things easier. If you need to look for something about FastAPI, you usually don’t need to look anywhere else.

In addition, FastAPI will automatically generate interactive API documentation from the program we are running. So that we don’t need to write the API documentation that we created ourselves. As we all know, writing API documentation is annoying, not only because there is a lot of detail to go into, but also nothing more frustrating when the end-users are implementing but not match up the documentation. So that with the automatic generation of API documentation it will be very helpful

Below is a display example of the API documentation (provided by Swagger UI)

Alternative automatic documentation is also provided (provided by ReDoc)

To define the created schema, it uses Pydantic, which is another awesome Python library, used for data validation. Its purpose is to validate the input that goes to FastAPI. If the input/request is incorrect then the appropriate error code will be returned.

# Source: https://medium.com/@tiangolo/introducing-fastapi-fdc1206d453f

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float
    is_offer: bool = None

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

@app.put("/items/{item_id}")
def create_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

Performance

As the name implies, this is indeed FastAPI. Based on data from techempower benchmarks, FastAPI beats every framework when it comes to performance. Where the most commonly used frameworks like Flask and Django lag behind.

Yeah, it blazingly fast.

Asynchronous

One of the drawbacks of Flask is the lack of asynchronous I/O support. Asynchronous is pretty important for HTTP endpoints, which tend to do a lot of waiting for I/O and network chat, making it a good one candidate for concurrency using async.

Unlike Flask, FastAPI supports asynchronous code out of the box using the async/await Python keywords. FastAPI supports asynchronous by default, which means we don’t need to use a third-party framework to do asynchronous.

All you have to do is declare the endpoints with the async keyword like this:

@app.get('/book')
async def read_book():
    book = await get_book()
    return book

In conclusion, FastAPI is a fast web framework and supports asynchronous code. In addition, this is coupled with very complete documentation and an integrated validation system that makes it easier to use.

Are you interested in using FastAPI? If you want to get started using FastAPI, there are some great resources out there. Here are some that you can explore.