DEV Community: Oktapian Candra

Change the Python Version as You Like: Become the Python Wizard with pyenv

Oktapian Candra — Tue, 25 Feb 2025 07:15:46 +0000

Ah, Python developers—always on the cutting edge of innovation, until the day you clone a repository and realize it only works with Python 3.8. You’re running Python 3.10 or, worse, Python 3.11, and now all your hopes and dreams are dashed by an infuriating error message that might as well say, “Sorry, pal. Wrong Python.”

But fear not, for today we’re diving into pyenv, the magical tool that lets you change Python versions the way you’d change socks (though hopefully, you do that daily). By the end of this article, you’ll be switching Python versions like a pro, showing off to your colleagues, and maybe even naming yourself the “Keeper of the Snakes.”

Why Does Python Versioning Even Matter?

Let’s face it: Python developers have trust issues with versioning. It all started with the split between Python 2 and Python 3 (RIP Python 2, we’ll always remember your print statements without parentheses). Fast forward to today, and Python releases new versions faster than you can debug your latest TypeError.

Here’s the thing: not all Python projects are created equal. Some depend on older versions for compatibility reasons, while others thrive on the bleeding edge. And let’s not forget the chaos when you’re juggling multiple projects, each screaming for a different Python version.

This is where pyenv swoops in to save the day, like a superhero with a cape made of Python syntax.

What is pyenv?

In simple terms, pyenv is a Python version management tool that allows you to install, switch, and manage multiple Python versions on the same machine. It’s like a magical wardrobe that lets you choose the Python version you need for the job at hand.

Key Features of pyenv:

Install Multiple Versions: Easily install any version of Python, from the ancient days of 2.7 to the shiny new releases of 3.x.
Version Switching: Switch between global, local (project-specific), or shell-specific Python versions effortlessly.
No More Conflicts: No more fighting with your system Python installation or accidentally breaking things your operating system depends on.

Think of pyenv as your personal Python librarian. You ask for Python 3.8.10? It hands it to you on a silver platter. Need Python 3.11 for another project? No problem—it’s like having every Python version in your back pocket.

Step 1: Installing pyenv (Let’s Get This Party Started)

Before we start swapping Python versions like Pokémon cards, we need to install pyenv. Here’s how to do it:

1. Install Required Dependencies

First, let’s make sure we have all the necessary tools for building Python versions. Run the following commands based on your operating system:

sudo apt update  
sudo 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 python3-openssl git

2. Install pyenv

Now, let’s install pyenv itself. Run the following command:

curl -fsSL https://pyenv.run | bash

3. Update Your Shell Configuration

Next, we need to add pyenv to your shell startup file so it runs automatically when you open a terminal. If you’re using bash, add the following lines to your ~/.bashrc or ~/.bash_profile:

export PYENV_ROOT="$HOME/.pyenv"  
[[ -d $PYENV_ROOT/bin ]] && export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init - bash)"

For zsh, add these lines to your ~/.zshrc instead.

Finally, reload your shell:

exec "$SHELL"

4. Verify Installation

Check if pyenv is installed correctly by running:

pyenv --version

If you see something like pyenv 2.3.0, you’re good to go. If not, double-check the steps above and try not to yell at your computer (it’s sensitive, you know).

Step 2: Installing and Switching Python Versions

Now comes the fun part: installing and switching between Python versions like a true Python wizard.

Installing a Python Version

Let’s say you need Python 3.8.10 for a project. Simply run:

pyenv install 3.8.10

Want Python 3.10.9, the cool new kid on the block? No problem:

pyenv install 3.10.9

You can see a full list of available versions with:

pyenv install --list

Setting a Global Python Version

To set a global (default) Python version for your entire system, use:

pyenv global 3.10.9

Now, every time you open a terminal, Python 3.10.9 will be your default.

Setting a Local Python Version

Want to use a specific Python version for a particular project? Navigate to your project directory and run:

pyenv local 3.8.10

This creates a .python-version file in the directory, telling pyenv to use Python 3.8.10 whenever you’re working in this project.

Temporarily Changing Python Version

If you just want to switch Python versions temporarily (e.g., for a quick test), use:

pyenv shell 3.8.10

This sets the Python version for your current shell session only. Once you close the terminal, it’s back to the default.

Step 3: Living the Dream

Congratulations! You’re now the proud owner of a flexible Python environment. No more arguing with your system Python installation or worrying about breaking dependencies. With pyenv, you can:

Seamlessly switch between Python versions.
Develop multiple projects with different Python requirements on the same machine.
Impress your developer friends with your newfound Python wizardry.

Bonus: pyenv + Virtual Environments = True Happiness

If you want to take things to the next level, combine pyenv with virtual environments using pyenv-virtualenv. This allows you to create isolated environments for each project, each with its own Python version and dependencies.

Install it with:

pyenv install pyenv-virtualenv

And then create a virtual environment:

pyenv virtualenv 3.8.10 my-awesome-env
pyenv activate my-awesome-env

Now you’re not just a Python wizard—you’re a Python ninja.

Wrapping Up

With pyenv, you’ve unlocked the power to switch Python versions as easily as you change your Spotify playlist. No more version conflicts, no more dependency nightmares—just smooth, efficient Python development.

So go forth, Keeper of the Snakes, and wield your Python versions wisely. And remember: with great power comes great responsibility… and probably a lot of late-night coding.

Happy coding, and may your pip install commands always succeed on the first try!

Create package using Poetry, and deploy on private PyPi Server

Oktapian Candra — Tue, 18 Feb 2025 05:46:47 +0000

Ah, Python developers—masters of their craft, wielders of virtual environments, and occasional snackers of leftover pizza at 3 a.m. If you’ve ever wanted to create your own private Python package (because who doesn’t want to feel like a package-deploying secret agent?), this article will guide you through the process using Poetry and pypiserver. By the end, you’ll not only have a private package but also a sense of accomplishment rivaled only by successfully debugging a KeyError at first glance.

What is Poetry? (Not the Rhyming Kind)

Before you start imagining yourself as a wordsmith crafting verses under the moonlight, let me clarify: Poetry in this context is a tool for managing Python projects. It simplifies dependency management, package versioning, and publishing. Think of it as your Python project’s personal assistant—organizing everything neatly so you can focus on writing code (and googling stack traces).

Key Features of Poetry:

Dependency Management: Specify, resolve, and manage your project dependencies in one place.
Virtual Environment Integration: Automatically creates virtual environments for your project.
Packaging Made Easy: Build and publish Python packages with minimal effort—no need to wrestle with setup.py.

In short, Poetry is like that one coworker who always keeps their desk tidy and remembers everyone’s birthday.

What is pypiserver? (Hint: It’s Not a Fancy Dessert)

Now, let’s talk about pypiserver: a simple, lightweight PyPI (Python Package Index) server you can host yourself. Why would you want this? Well, maybe you’re building proprietary software, or maybe you just want to feel like a Python supervillain hoarding private packages. Either way, pypiserver lets you securely host and serve your own packages without relying on public repositories like PyPI.

Key Features of pypiserver:

Private Package Hosting: Store your own packages locally or on a private server.
Lightweight: Minimal setup and resource usage, perfect for small-scale hosting.
Compatibility: Works seamlessly with pip and other Python tools.

Essentially, it’s like running your own private PyPI, but without needing a degree in server management.

Why Would You Want a Private Package Anyway?

Good question! Here are some common reasons:

You have proprietary code you don’t want to share with the world.
You’re building reusable modules for internal use within your organization.
You just want to flex on your teammates by saying, “Oh, I have my own PyPI server.”

Now that we’ve got the basics down, let’s jump into the fun part: creating a private package and deploying it on pypiserver.

Step 1: Install Poetry

First, install Poetry. If you don’t already have it, run the following command:

curl -sSL https://install.python-poetry.org | python3 -

After installation, make sure Poetry is accessible by checking its version:

poetry --version

If you see something like Poetry version 1.6.0, congratulations—you’re ready to roll. If not, double-check your installation steps, and try not to curse too loudly.

Step 2: Create Your Python Package

Let’s create that private package. For this example, we’re going to make a package called my_private_package because creativity is overrated. Run the following:

poetry new my_private_package

This command creates a new directory with the following structure:

my_private_package/  
├── my_private_package/  
│   └── __init__.py  
├── tests/  
│   └── __init__.py  
├── pyproject.toml

The pyproject.toml file is Poetry’s version of a project blueprint. It defines everything about your project, from its dependencies to its version number.
The tests/ directory is where you can write tests… you know, once you stop procrastinating.

Step 3: Write Some Code

Now, let’s add some code to your package. Open my_private_package/__init__.py and add the following:

def greet(name: str) -> str:  
    return f"Hello, {name}! Welcome to your private package."

It’s simple, but hey, it gets the job done.

Step 4: Build the Package

To build your package, navigate to the root directory of your project and run:

poetry build

This will create a dist/ directory containing .tar.gz and .whl files for your package. These are the files you’ll upload to your private PyPI server (or, as I like to call it, your “Python treasure chest”).

Step 5: Set Up pypiserver

Install pypiserver

Now it’s time to set up your private PyPI server. First, install pypiserver:

pip install pypiserver

Create a Directory for Your Packages

Decide where you want to store your private packages. For example:

mkdir ~/private_packages

Add security using htpasswd

Create a user and choose a beautiful password for your private PyPi Server

htpasswd -sc ~/private_packages/htpasswd.txt admin

Start the Server

Run the following command to start pypiserver:

pypi-server run -p 8060 ~/private-packages -P ~/private-packages/htpasswd.txt --hash-algo=sha256

This will start the server on http://localhost:8060. You can now upload and serve packages from this directory.

Step 6: Deploy Your Package to pypiserver

Let’s back to my_private_packageproject directory, and add this on your private PyPi Server (let name it as “treasure_chest”) to the pyproject.toml:

[[tool.poetry.source]]  
name = "treasure_chest"  
url = "http://localhost:8060/simple/"  
priority = "supplemental"

To upload packages to a server with Poetry, you must first configure it.

poetry config repositories.treasure_chest http://localhost:8060/  
poetry config http-basic.treasure_chest admin "<your_beautiful_password>"

Then, yeah this time for upload your packages using this command:

poetry publish --repository treasure_chest

This will upload your package on dist/to your private PyPi Server, and you will see your packages on http://localhost:8060/simple/.

Step 7: Install Your Private Package

Using pip install

To install your private package from pypiserver, use pip with the --extra-index-url option:

pip install --extra-index-url http://localhost:8080 my_private_package

Using poetry

Or.. you can install it using poetry, with add your private PyPi server configuration on your pyproject.toml like in the package directory earlier

[[tool.poetry.source]]  
name = "treasure_chest"  
url = "http://localhost:8060/simple/"  
priority = "supplemental"

Then running this command

poetry add --source treasure_chest my_private_package

If you see Successfully installed my_private_package, congratulations—you’ve officially entered the realm of private package ninjas.

Wrapping Up

And there you have it! You’ve created a private Python package using Poetry and deployed it on pypiserver. Whether you’re building an empire of proprietary modules or just trying to impress your developer friends, you now have the tools to do it.

Remember, with great power comes great responsibility. Use your private PyPI server wisely, and don’t forget to share this tutorial with your favorite Python buddies. Or don’t—it’s your secret package lair, after all.