DEV Community: Yuki Nagae

Setup Fira Code font for Visual Studio Code

Yuki Nagae — Sat, 07 Jan 2023 12:51:32 +0000

Install Fira Code via brew:

brew tap homebrew/cask-fonts
brew install --cask font-fira-code

Or you can do the same thing with a .Brewfile.
First edit ~/.Brewfile as:

tap "homebrew/cask-fonts"
cask "font-fira-code"

And install with the .Brewfile by the below brew command:

brew bundle install --global

Also, edit your Visual Studio Code settings.json :

{
    "editor.fontFamily": "Fira Code",
    "editor.fontLigatures": true,
}

"asdf" multiple runtime version manager to install node.js

Yuki Nagae — Fri, 06 Jan 2023 12:58:40 +0000

asdf is a runtime version management tool. It is similar to other tools such as rbenv (for ruby), nvm (for node), goenv (for golang).

Those tools focus on one language runtime, on the other hand asdf covers most of those language runtimes. Using asdf, you don't have to install each runtime version manager tool one by one, just asdf is enough.

Install asdf via brew:

brew install asdf

Add node.js plugin for asdf:

asdf plugin-add nodejs

Install node.js latest version and set it on a global context:

asdf install nodejs latest
asdf global nodejs

You can specify a version instead of "latest":

asdf install nodejs 19.3.0

Check node.js and npm versions (versions depend on your environment):

$ node -v
v19.3.0
$ npm -v
9.2.0

That's all!

Beginner Guide on “Poetry”, New Python dependency management tool

Yuki Nagae — Sat, 20 Apr 2019 09:33:04 +0000

Why I write this post?

Once I wrote a blog post about “pipenv”, which is one of the Python package management tools, Dylan gave me a comment on the post.

He pointed out some of the issues on pipenv, and his suggestion was to use Poetry instead of pipenv.

In this post, I’ll briefly cover what Poetry is and some usage of it. This is just a first try to use Poetry, and hopefully, I write more details in the future blog posts :)

What is “Poetry” and why?

Poetry is a Python dependency management tool.

The main reason why Poetry developed is mentioned here.

Packaging systems and dependency management in Python are rather convoluted and hard to understand for newcomers. Even for seasoned developers it might be cumbersome at times to create all files needed in a Python project:setup.py, requirements.txt, setup.cfg, MANIFEST.in and the newly added Pipfile.

This is really true that there are many files we should consider such as:

setup.py
requirements.txt
setup.cfg
MANIFEST.in
Pipfile and Pipfile.lock (pipenv)

To solve this messy situation, Poetry comes here for us with only one pyproject.toml file to manage all the dependencies.

Now, let’s setup Poetry!

Setup Poetry

Requirements

Python 2.7 or 3.4+

I’ll use Python 3.6.0 in this post.

$ python --version
Python 3.6.0

Installation

Install Poetry via an installer provided.

$ curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python
Retrieving Poetry metadata

# Welcome to Poetry!

This will download and install the latest version of Poetry,
a dependency and package manager for Python.

It will add the `poetry` command to Poetry's bin directory, located at:

$HOME/.poetry/bin

This path will then be added to your `PATH` environment variable by
modifying the profile files located at:

$HOME/.profile
$HOME/.bash_profile

You can uninstall at any time with `poetry self:uninstall`,
or by executing this script with the --uninstall option,
and these changes will be reverted.

Installing version: 0.12.12
  - Downloading poetry-0.12.12-darwin.tar.gz (7.23MB)

Poetry (0.12.12) is installed now. Great!

To get started you need Poetry's bin directory ($HOME/.poetry/bin) in your `PATH`
environment variable. Next time you log in this will be done
automatically.

To configure your current shell run `source $HOME/.poetry/env`

To activate poetry command, run the following command:

source $HOME/.poetry/env

Now, poetry command should be available. Let’s check the Poetry version installed.

$ poetry —version
Poetry 0.12.12

It works!

Poetry demo

Create a template

First, I’ll create a demo app.

poetry new poetry-demo

The project structure is like this.

$ cd poetry-demo
$ tree
.
├── README.rst
├── poetry_demo
│   └── __init__.py
├── pyproject.toml
└── tests
    ├── __init__.py
    └── test_poetry_demo.py

Let’s see pyproject.toml.

[tool.poetry]
name = "poetry-demo"
version = "0.1.0"
description = ""
authors = ["[Your Name] <[Your Email]>"]

[tool.poetry.dependencies]
python = "^3.6"

[tool.poetry.dev-dependencies]
pytest = "^3.0"

[build-system]
requires = ["poetry>=0.12"]
build-backend = "poetry.masonry.api"

Add dependency

I can specify a dependency in the pyproject.toml file directly, but it looks easy for me to use add command.

poetry add pendulum

Automatically, pendulum is added to the pyproject.toml file.

[tool.poetry.dependencies]
python = "^3.6"
pendulum = "^2.0"

Also, poetry.lock is created.

$ tree
.
├── README.rst
├── poetry.lock
├── poetry_demo
│   └── __init__.py
├── pyproject.toml
└── tests
    ├── __init__.py
    └── test_poetry_demo.py

Since this is just a first try to use Poetry, I’ll continue using it and may write a blog post again if I find something useful :)

TODO

There are several things I’d like to try:

[ ] How to integrate with existing requirements.txt?
[ ] Try Poetry publish command to publish my package to PyPI
[ ] Compare Poetry with pipenv

References

Poetry
- Poetry - Python dependency management and packaging made easy.: Official documentation
- sdispater/poetry: Python dependency management and packaging made easy.: GitHub
Python Application Dependency Management in 2018 · Homepage of Hynek Schlawack

Your First Guide to Getting Started with “pipenv”

Yuki Nagae — Wed, 17 Apr 2019 06:29:55 +0000

What is “pipenv”?

There are many package manager tools in other programming languages such as:

Ruby
- bundler
PHP
- composer
NodeJS
- npm
- yarn
Rust
- cargo

If you know any of the above tools, it might be easy to understand what it is.
pipenv is just a package management tool for Python as same as those tools.

Why “pipenv”?

The official documentation Pipenv: Python Dev Workflow for Humans and this blog post Why Python devs should use Pipenv would tell us why we should use pipenv.

Two main problems of “before” pipenv workflow are following:

Using pip and virtualenv separately is not necessary any more!
requirements.txt is problematic: see A Better Pip Workflow™
- without version specified -> different versions every time for dev/prod environments!
- with version specified -> --upgrade is hard!

If we look back on the history of Python package management tools, there are many tools before, and this is terrible.

Package manager
- Easy Install
- pip
Many many virtual environment tools
- virtualenv
- venv
- pyenv
- pyenv-virtualenv
- etc

Finally, pipenv comes to our rescue!

Setup pipenv

Check Python version (should be 3.x)

$ python --version
Python 3.6.0

Check pip version

$ pip --version
pip 18.1

Install pipenv

brew install pipenv

Check pipenv version

$ pipenv --version
pipenv, version 2018.11.26

Success: pipenv is installed!

pipenv workflow

Install dependencies (pipenv automatically detect requirements.txtand solve the dependencies)

$ cd [YOUR PROJECT]
$ pipenv install

Pipfile and Pipfile.lock should be created

Pipfile: list of all installed packages

(Pipfile example)

[[source]]
name = "pypi"
url = "https://pypi.org/simple"
verify_ssl = true

[dev-packages]

[packages]
jupyter = "*"
seaborn = "*"
numpy = "*"
pandas = "*"
plotly = "*"
scipy = "*"
six = "*"
sklearn = "*"
pyspark = "*"
flake8 = "*"
autopep8 = "*"
Flask = "*"

[requires]
python_version = "3.7"

Pipfile.lock: maintain a proper dependencies and sub packages with version

(Pipfile.lock example)

{
    "_meta": {
        "hash": {
            "sha256": "xxxxxxxxxxxxxxxxxxxxxxxx"
        },
        "pipfile-spec": 6,
        "requires": {
            "python_version": "3.7"
        },
        "sources": [
            {
                "name": "pypi",
                "url": "https://pypi.org/simple",
                "verify_ssl": true
            }
        ]
    },
    "default": {
        "appnope": {
            "hashes": [
                "sha256: xxxxxxxxxxxxxxxxxxxxxxxx",
                "sha256: xxxxxxxxxxxxxxxxxxxxxxxx"
            ],
            "markers": "sys_platform == 'darwin'",
            "version": "==0.1.0"
        },
        "attrs": {
            "hashes": [
                "sha256: xxxxxxxxxxxxxxxxxxxxxxxx",
                "sha256: xxxxxxxxxxxxxxxxxxxxxxxx"
            ],
            "version": "==19.1.0"
        },
        "autopep8": {
            "hashes": [
                "sha256: xxxxxxxxxxxxxxxxxxxxxxxx"
            ],
            "index": "pypi",
            "version": "==1.4.4"
...

Now, run your python script (Installed packages are available when you use pipenv run)

$ pipenv run python [YOUR PYTHON MAIN SCRIPT]
Pipfile.lock not found, creating…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
✔ Success! 
Updated Pipfile.lock (980232)!
Installing dependencies from Pipfile.lock (980232)…
  🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 73/73 — 00:01:22
To activate this project's virtualenv, run pipenv shell.
Alternatively, run a command inside the virtualenv with pipenv run.

Thanks for reading!
If you enjoyed this article, feel free to hit that clap button 👏.

References

Pipenv: Python Dev Workflow for Humans: Official documentation
Why Python devs should use Pipenv: Why pipenv?
The Hitchhikers guide to pipenv: pipenv guide
Python Dependency Management with pipenv: pipenv guide
Five Myths About Pipenv