Developer-Tools | Bas Nijholt

Python environments that stuck: micromamba and uv 🐍

Fri, 03 Jan 2025 00:00:00 +0000

1. Introduction 🚀 #

Like many Python developers, I’ve spent considerable time trying different environment management tools to find what works best for me.

After exploring various options from virtualenv to Conda, I found that Conda-based solutions fit my needs well - mainly because they handle non-Python dependencies without much hassle.

While Conda itself can be slow when setting up environments, tools like Mamba and Pixi provide the same functionality with better performance.

In this post, I’ll share my experience with different Python environment tools and provide practical commands for setting up Python environments.

Table of contents

2. The Alternatives 🌟 #

Before we start look at this comparison tables for the most popular Python environment management tools.

I had to split the tables into two because of the number of columns.

Table 1: Python Environment Management Tools

Tool	Key Features	Native/3rd Party	Non-Python Deps
Pyenv	Python version management	3rd Party	❌
Pipenv	Package & env management	3rd Party	❌
Conda	Package & env management	3rd Party	✅
Mamba	Fast Conda replacement	3rd Party	✅
Micromamba	Lightweight Mamba	3rd Party	✅
Docker	Containerization	3rd Party	✅
Venv	Built-in env management	Native	❌
Virtualenv	Env management (pre-3.3)	3rd Party	❌
Homebrew	macOS/Linux package manager	3rd Party	✅
Pixi	Fast Conda alternative	3rd Party	✅
uv	Fast pip and venv replacement	3rd Party	❌
System Package Managers	OS-based package management	Native	✅

Table 2: Python Environment Management Tools

Tool	Ease of Use	Isolation	Cross-Platform Support	Community & Support	Performance
Pyenv	Medium	✅	Windows, macOS, Linux	Good	Good
Pipenv	Easy	✅	Windows, macOS, Linux	Good	Good
Conda	Easy	✅	Windows, macOS, Linux	Excellent	Average
Mamba	Easy	✅	Windows, macOS, Linux	Growing	Fast
Micromamba	Medium	✅	Windows, macOS, Linux	Growing	Fast
Docker	Hard	✅	Windows, macOS, Linux	Excellent	Good
Venv	Easy	✅	Windows, macOS, Linux	Excellent	Good
Virtualenv	Medium	✅	Windows, macOS, Linux	Good	Good
Homebrew	Easy	❌	macOS, Linux	Excellent	Good
Pixi	Easy	✅	Windows, macOS, Linux	Growing	Fast
uv	Easy	✅	Windows, macOS, Linux	Growing	Very Fast
System Package Managers	Easy	❌	Depends on OS	Depends on OS	Good

Now that we’ve seen the alternatives, let’s dive into setting up environments with the help of Conda and Mamba.

🐍 Pyenv #

A popular tool that enables you to easily manage multiple Python versions on a single system. It allows you to switch between different Python versions without interfering with system-level installations.

Setup Instructions

Install pyenv:
- macOS: brew install pyenv
- Ubuntu: curl https://pyenv.run | bash
Add the following lines to your shell configuration file (e.g., ~/.bashrc, ~/.zshrc):
```
export PATH="$HOME/.pyenv/bin:$PATH"
eval "$(pyenv init -)"
```
Restart your shell or run source ~/.bashrc (or source ~/.zshrc)
Install a specific Python version: pyenv install 3.8.5
Set the Python version for your project: pyenv local 3.8.5

📦 Pipenv #

A package management and virtual environment management tool that combines the functionality of pip and virtualenv. It streamlines the process of installing and managing packages within isolated environments.

Setup Instructions

Install pipenv: pip install --user pipenv
Change to your project directory: cd my_project
Initialize a new virtual environment: pipenv --python 3.8
Install packages: pipenv install <package_name>
Activate the environment: pipenv shell

🌐 Conda #

A cross-platform package manager and environment management tool, often used in conjunction with Anaconda and Miniconda. Conda simplifies the installation and management of packages and dependencies, especially for data science and machine learning projects.

Setup Instructions

Download and install Miniconda: https://github.com/conda-forge/miniforge#miniforge3
Create a new environment: conda create --name my_env python=3.8
Activate the environment: conda activate my_env
Install packages: conda install <package_name>

🚀 Mamba #

Mamba is a fast, drop-in replacement for Conda, designed to resolve and install packages more quickly. It uses the same Conda repositories and environment files, making it easy to switch between the two.

Setup Instructions

Install Mambaforge with Mamba pre-installed:

Download and install Mambaforge with Mamba for your platform: https://github.com/conda-forge/miniforge#mambaforge

Alternatively, you can install Mamba within an existing Conda environment:
```
conda install -c conda-forge mamba
```
Create a new environment with Mamba:
```
mamba create --name my_env python=3.8
```
Activate the environment:
```
mamba activate my_env
```

Install packages using Mamba:

mamba install <package_name> -c conda-forge

By using Mamba instead of Conda, you can significantly speed up environment resolution and package installation while still benefiting from the Conda ecosystem.

🌌 Micromamba #

Micromamba is a lightweight and fast alternative to the Mamba package manager. It is a statically linked C++ executable that doesn’t require a base environment or come with a default Python version. It supports a subset of Mamba and Conda commands and is designed to resolve and install packages quickly. For those who need Conda features, you can install Conda using Micromamba with micromamba install conda.

Setup Instructions

Download the appropriate Micromamba binary for your platform from the official repository.
Make the binary executable and move it to a directory in your PATH:
```
chmod +x micromamba mv micromamba /usr/local/bin/
```

Create a new environment with Micromamba:

micromamba create -n my_env python -c conda-forge

Activate the environment:
```
micromamba activate my_env
```

Install packages using Micromamba:

micromamba install <package_name> -c conda-forge

If you need Conda’s features, you can install Conda within your Micromamba environment:
```
micromamba install conda
```

For example, if you need nb_conda_kernels to use your Micromamba environment in JupyterLab:

micromamba install conda nb_conda_kernels

And you are set up!

Micromamba is the perfect solution for those who want a fast and lightweight package manager while still being able to access Conda’s features when needed.

🐳 Docker #

A containerization platform that allows you to create lightweight, portable environments called containers. With Docker, you can package your Python application along with its dependencies, ensuring consistent execution across different systems.

Setup Instructions

Install Docker: https://docs.docker.com/get-docker/

Create a Dockerfile in your project directory with the following contents:

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
CMD ["python", "your_script.py"]

Build the Docker image: docker build -t my_project .
Run the Docker container: docker run my_project

🏞️ Venv #

A built-in Python module available since Python 3.3, which allows you to create lightweight virtual environments. Venv simplifies the process of creating isolated environments for different projects, ensuring that package dependencies don’t conflict with each other.

Setup Instructions

Create a new virtual environment: python3 -m venv my_env
Activate the environment:
- macOS/Linux: source my_env/bin/activate
- Windows: my_envScriptsactivate
Install packages: pip install <package_name>

🌐 Virtualenv #

Virtualenv is a third-party Python environment management tool that predates the built-in venv module. It allows you to create isolated environments for different projects, ensuring that package dependencies don’t conflict with each other. Virtualenv is compatible with Python 2.7 and later versions, whereas venv is only available since Python 3.3.

Setup Instructions

Install virtualenv: pip install virtualenv
Create a new virtual environment: virtualenv my_env
Activate the environment:
- macOS/Linux: source my_env/bin/activate
- Windows: my_env\Scripts\activate
Install packages: pip install <package_name>

🍺 Homebrew #

Homebrew is a popular package manager for macOS and Linux that simplifies the installation and management of software. Though it is not a dedicated Python environment management tool, it does offer support for installing and managing multiple Python versions alongside other software.

Homebrew can be useful for installing and managing Python versions for system-level usage, but it’s not the best choice for managing isolated project-specific dependencies. For project-specific dependency management, it’s recommended to use other tools like venv, virtualenv, or Conda in conjunction with Homebrew-installed Python.

Setup Instructions

Install Homebrew (if not already installed):
- macOS: Follow the instructions at https://brew.sh
- Linux: Follow the instructions at https://docs.brew.sh/Homebrew-on-Linux
Install a specific Python version:
```
brew install python@3.11
```
Add the installed Python version to your PATH by adding the following line to your shell configuration file (e.g., ~/.bashrc, ~/.zshrc):
```
export PATH="/usr/local/opt/python@3.11/bin:$PATH"
```
Restart your shell or run source ~/.bashrc (or source ~/.zshrc) to apply the changes.
Verify the Python version: python3.11 --version

Keep in mind that Homebrew is mainly for installing and managing software at the system level. To manage project-specific dependencies and create isolated environments, combine Homebrew with other tools like venv or virtualenv for better dependency management.

💻 System package managers #

Some operating systems have their own package managers (e.g., apt for Ubuntu, pacman for Arch Linux, or Homebrew for macOS) that can be used to install and manage Python environments. However, using system package managers may lead to conflicts with other system packages and is generally not recommended for managing project-specific dependencies.

I will skip the setup instructions for this one, as it is just not recommended to do this!

🌟 Pixi #

Pixi is a new package manager built in Rust that uses Conda-forge packages but aims to be significantly faster and simpler than Conda. It’s developed by prefix.dev (the team behind Mamba) and focuses on providing a more streamlined experience. It is inspired by tools like Cargo, nix, and npm and aims to provide a modern package management experience for Python developers.

Setup Instructions

Install pixi following instructions at prefix.dev
Initialize a new project:
```
pixi init my-project
cd my-project
```
Add dependencies:
```
pixi add python numpy pandas
```
Run Python in the environment:
```
pixi run python
```

Create and run tasks (defined in pixi.toml):

# Add a task
pixi task add hello "python hello_world.py"

# Run the task
pixi run hello

Start an interactive shell in the environment:
```
pixi shell
```

Pixi can also be used as a global installation tool:

# Install tools globally
pixi global install starship
pixi global install fish

# Create a named environment with multiple packages
pixi global install --environment data-science-env \
 --expose python --expose jupyter \
 python jupyter numpy pandas

Key features:

Fast package resolution and installation
Uses Conda-forge packages
Built-in task runner
Global package installation support
GitHub Actions integration with automatic caching
Simple and intuitive CLI

⚡ uv #

uv is an extremely fast Python package installer and resolver written in Rust. It can be used as a drop-in replacement for pip and can generate virtual environments. While it is quite new it is already being used by many developers due to its speed and ease of use. Besides being fast, it is awesome because it is a single binary that can be used to also bootstrap Python itself.

Setup Instructions

Install uv:

curl -LsSf https://astral.sh/uv/install.sh | sh

Create a new virtual environment:
```
uv venv
```
Activate the environment:
- Unix/macOS: source .venv/bin/activate
- Windows: .venv\Scripts\activate
Install packages (much faster than pip):
```
uv pip install numpy pandas
```

It will automatically maintain a uv.lock file to ensure deterministic builds. Install this lock file with uv sync.

Key features of uv:

Up to 10x faster than pip
Built-in virtual environment support
Compatible with pip’s CLI interface
Global package caching
Deterministic builds

There is much more to uv, so check out the documentation for more details.

3. Conclusion 🏁 #

The choice you make for managing your Python environments ultimately depends on your use case. If you don’t have to frequently deal with non-Python dependencies, I would recommend using uv for its speed and simplicity. However, because I often work with projects that require non-Python dependencies, I’ve found that Micromamba is the perfect fit for me.

That being said, each tool has its own strengths and weaknesses, and it’s important to choose the one that works best for your specific needs. I hope this journey through Python environment management has been helpful and informative. Good luck in finding your perfect Python environment workflow! 🐍

4. Further Reading 📚 #

Here are some resources for further exploration:

Pyenv: Pyenv GitHub repository and documentation
Pipenv: Pipenv documentation
Conda: Conda documentation
Mamba: Mamba documentation
Micromamba: Micromamba documentation
venv: venv documentation
virtualenv: virtualenv documentation
Anaconda: Anaconda homepage
Miniconda: Miniconda documentation
Homebrew: Homebrew homepage
Pixi: Pixi documentation
uv: uv documentation

fileup 📤

Thu, 19 Dec 2024 00:00:00 +0000

(See my intro post)

Sometimes the best tools are the ones you build for yourself and keep using for years. Today’s project is fileup, a tiny command-line utility that’s been making my life easier for 7 years - because sharing files shouldn’t require leaving the terminal!

📖 Origin Story #

Back in 2017, I found myself repeatedly going through the same tedious process: needing to share a file, opening a browser, navigating to a file sharing service, waiting for uploads, and copying URLs. As someone who lives in the terminal, this felt inefficient. I wanted something as simple as fu filename that would handle everything and put the URL in my clipboard. Seven years and countless file shares later, it’s still one of my most-used tools.

🔧 Technical Highlights #

Supports both FTP and SCP uploads
Smart URL generation:
- Jupyter notebooks → nbviewer links
- Images → markdown-formatted links
- Regular files → direct URLs
Automatic file expiration and cleanup
Zero dependencies - uses only Python standard library
Clipboard integration (macOS)
Simple INI configuration
Works as both a standalone script or installed package

📊 Impact #

This is one of those tools where GitHub stars (currently 0!) don’t tell the whole story:

Used almost daily for 7 years
Shared thousands of files
Saved countless minutes of browser interactions
Proves that utility trumps popularity in open source

💡 Lessons Learned #

Longevity comes from solving a real, persistent need
A tool doesn’t need to be revolutionary to be useful
Zero dependencies mean zero maintenance headaches
Sometimes the impact of a tool isn’t measured in stars
Simple tools that remove friction are worth maintaining

Want to share files from your terminal? Check out fileup on GitHub!

#OpenSource #Python #DevTools #CommandLine #Programming

clip-files 📋

Sun, 15 Dec 2024 00:00:00 +0000

(See my intro post)

Sometimes the most useful tools are born from daily frustrations. When working with AI assistants like ChatGPT or Claude, I found myself constantly copying files to share context. After doing this manually dozens of times, I created a tool to automate it.

📖 Origin Story #

While contributing to open source, I frequently like to share entire (or large parts of) codebases with AI assistants for context or code review. Since the code is open source anyway, there’s no reason not to share the full context! But manually copying files, adding their paths for context, and ensuring I didn’t exceed token limits was tedious. Instead of continuing this manual process, I spent an evening creating clip-files - and have used it multiple times daily ever since.

In fact, I’m using it right now! The command (shown below) lets me share this entire advent calendar series with AI assistants for proofreading.

clip-files --initial-file ai.md --files introduction.md day*.md

🔧 Technical Highlights #

Uses tiktoken for accurate GPT token counting
Supports both directory traversal and specific file selection
Automatically generates a file index for reference
Allows custom initial instructions via file
Preserves file paths in output for context
Clean, typed, and documented codebase

📊 Impact #

While this tool has no GitHub stars (I haven’t promoted it), its real impact is personal - I use it multiple times daily for:

Sharing entire open source codebases with AI assistants
Getting comprehensive code reviews
Discussing bug fixes with full context
Documentation improvements
Open source contributions

The tool’s real value isn’t in its complexity (it’s just ~250 lines of code) but in how it removes friction from open source development. When working with open code, we might as well share all the context we can - and this tool makes that effortless.

🎯 Challenges and Solutions #

Maintaining consistent formatting across different input methods
Calculating accurate token counts for different components
Providing meaningful error messages for invalid inputs
Structuring output to be AI-assistant friendly

💡 Lessons Learned #

When working with open source code, sharing full context is valuable
Simple command-line tools can significantly improve daily workflows
Consistent formatting matters when working with AI assistants
Sometimes a 250-line tool can save hours of manual work

Want to make sharing code with AI assistants easier? Check out clip-files on GitHub!

#OpenSource #Python #DevTools #AI #Programming

markdown-code-runner 📝

Thu, 05 Dec 2024 00:00:00 +0000

(See my intro post)

Documentation should be as close to the code as possible - that’s the principle of “information locality.” But how do you keep code examples and their outputs in sync? Enter markdown-code-runner, a tool that executes code blocks within Markdown files and updates their output in-place!

📖 Origin Story #

While maintaining various open source and work projects, I found myself constantly updating README or Wiki files with new command outputs, updated tables, and fresh examples. This manual process was error-prone and tedious. Instead of using external templating files or more advanced documentation generators like Sphinx and Quarto (which are often overkill for single-page projects), I wanted something simpler: code and its output living together in the same Markdown file, always in sync.

🔧 Technical Highlights #

Executes code blocks (Python and Bash) within Markdown files
Updates outputs in-place while preserving the original file structure
Supports hidden code blocks for generating content without showing the code
Works with any language by using file code blocks and bash execution
Zero external dependencies
GitHub Actions integration for automatic README updates
Preserves Markdown spec compatibility by hiding code in HTML comments ()

📊 Impact #

97 GitHub stars
Used in many of my other projects for auto-generating:
- Command-line help texts
- API documentation
- Example outputs
- Data tables
Helps maintain “information locality” - everything needed is in one file
Enables dynamic documentation that stays up-to-date automatically

🎯 Challenges and Solutions #

Parsing Markdown without breaking its structure
Supporting multiple programming languages
Making it work seamlessly with GitHub Actions
Handling complex outputs (tables, images, etc.)
Maintaining backward compatibility with existing Markdown files

💡 Lessons Learned #

Documentation is best when it’s close to what it documents
Automation should be invisible - the tool shouldn’t change how you write Markdown
Sometimes the simplest solution (using HTML comments) is the best
Good documentation tools should make maintaining docs easier, not harder
Auto-generated content should be clearly marked as such

Want to keep your documentation always in sync? Check out markdown-code-runner on GitHub!

#OpenSource #Python #Documentation #DevTools #Programming

Discovering Git worktrees: a handy tool for multitasking 📚

Thu, 19 Sep 2024 00:00:00 +0000

Recently, I discovered a game-changer in Git that has streamlined my workflow: worktrees. This feature allows developers to handle multiple branches of a single repository simultaneously, eliminating the need for constant branch-switching or multiple clones. For example, I typically want to keep the main branch in one editor window and the feature branch in another to easily test changes. With Git worktrees, I essentially have two separate working directories for each branch, making it easier to manage changes and switch between tasks.

What is a Git Worktree?

A Git worktree provides additional working directories linked to the same repository. This means you can easily work on different branches in parallel without duplicating repositories, saving both space and effort.

Benefits of Git Worktrees

Parallel Development: Effortlessly switch between branches for urgent bug fixes or new feature developments.
Efficiency: It’s lightweight, sharing the Git directory, and integrates smoothly with existing workflows.

Quick Commands

Create a Worktree:
git worktree add <path-to-new-worktree> <branch-name>
List Worktrees:
git worktree list
Remove a Worktree:
git worktree remove <path-to-worktree>

Conclusion

Incorporating Git worktrees into your workflow enhances productivity and organization. Whether dealing with bug fixes or new features, worktrees help maintain a cleaner environment.

My favorite tools that keep my Python projects sane 🧰

Sat, 22 Apr 2023 00:00:00 +0000

🌟 1. Introduction #

As a passionate Python developer, I am always on the hunt for the best tools to streamline my development process and enhance the quality of my projects. Over time, I have discovered a set of tools that have become indispensable in my workflow, making my coding experience more efficient and enjoyable. Using the right developer tools for Python projects is crucial for maximizing productivity, ensuring code consistency, and maintaining high-quality code.

In this blog post, I will share these essential tools that I now use for every single new project. We will explore the benefits of each tool and discuss how they can help you supercharge your Python development. The tools covered in this post include pre-commit, Black, Ruff, Mypy, Versioningit, Pyproject.toml with PEP 621, Nox, pytest, GitHub Actions CI matrix, and Read the Docs, Sphinx, MyST-NB, and Jupytext notebooks for documentation. Let’s dive in and learn how to enhance your Python projects with these powerful tools!

Table of contents

🛠️ 2. Pre-commit #

One of the most common challenges developers face when working on a project, whether alone or in a team, is maintaining code quality and consistency. As projects grow, it becomes increasingly difficult to enforce coding standards and catch issues before they make their way into the codebase. This is where pre-commit comes in.

Pre-commit is a powerful tool that helps you manage and maintain code quality by automating checks before commits. It achieves this by setting up a series of hooks that run before each commit, ensuring that only code that meets your predefined standards is committed to the repository. By catching issues early, pre-commit helps you keep your code clean and consistent, making it easier to review and maintain.

One of the reasons pre-commit has gained widespread adoption is its flexibility and extensibility. You can choose from a vast range of built-in hooks, such as code formatters, linters, and security checkers, or even create your own custom hooks. This allows you to tailor pre-commit to the specific needs of your project, ensuring that it enforces the exact coding standards you require.

Using pre-commit is beneficial for both individual developers and teams. For solo developers, it helps maintain discipline and enforces coding standards, making it easier to onboard collaborators in the future. For teams, it streamlines the review process by catching issues before they are submitted for review, reducing the time spent on addressing code inconsistencies and style violations.

Let’s take a look at an example. Suppose your project follows the PEP 8 coding standard, and you want to ensure that all code committed to the repository adheres to these guidelines. You can configure pre-commit to run a PEP 8 linter, such as Flake8, before each commit. This way, any code that does not meet the PEP 8 standard will be flagged, and the commit will be blocked until the issues are resolved.

In summary, pre-commit is an invaluable tool for maintaining code quality and consistency in your Python projects. By automating checks before commits, it ensures that your codebase remains clean and adheres to your chosen standards, making your development process more efficient and enjoyable.

Adding pre-commit to your Python project is simple and straightforward. To get started, you’ll first need to install the pre-commit package using pip:

pip install pre-commit

Next, create a configuration file named .pre-commit-config.yaml in your project’s root directory. This file will define the hooks you want to run before each commit. For example, to use Black for code formatting and Flake8 for linting, your configuration file might look like this:

repos:
 - repo: https://github.com/psf/black
 rev: stable
 hooks:
 - id: black
 - repo: https://github.com/pycqa/flake8
 rev: master
 hooks:
 - id: flake8

Once you have set up the configuration file, run the following command to install the pre-commit hooks:

pre-commit install

Now, every time you attempt to make a commit, pre-commit will run the specified hooks. If any issues are found, the commit will be blocked, and you’ll be prompted to fix the problems before trying again. To run pre-commit manually on all files in your repository, use the following command:

pre-commit run --all-files

By incorporating pre-commit into your development process, you’ll be able to catch and fix issues before they make their way into your codebase, ensuring a consistent and high-quality Python project.

🎨 3. Black: auto-formatting for Python #

As a developer who has always been particular about coding style, I’ve had my fair share of discussions on the proper way to indent multiline statements and other formatting nuances. These conversations, although sometimes necessary, can take up valuable time that could be better spent on actual development. That’s where Black, the uncompromising code formatter, comes in and saves the day.

Adopting Black has made a significant impact on my development workflow. No more unnecessary discussions about formatting preferences; everyone on the team simply follows the rules set forth by Black. This consistency across the codebase not only makes the code more readable but also reduces the time spent on formatting debates.

One of the best aspects of Black is that you don’t need to worry about writing perfectly formatted code initially. You can write your code as quickly as you want, even if it’s poorly formatted, and then simply run Black to transform it into a beautifully formatted masterpiece. This can be a real time-saver, especially when working on large projects with many contributors.

To install Black, run the following command:

pip install black

You can then format your code by running Black in the terminal:

black your_file.py

Alternatively, you can use the VS Code command palette to run Black on the currently open file. However, the most efficient way to use Black is in combination with pre-commit, as mentioned in the previous section. This way, your code is automatically formatted every time you commit, ensuring a consistent codebase without any extra effort.

In summary, Black is an invaluable tool for enforcing consistent code formatting throughout your Python projects. By adopting it and integrating it with pre-commit, you can save time and focus on what truly matters: writing great code.

🚀 4. Ruff: the fastest Python linter and auto-formatter #

In the past, I’ve used several tools to maintain code quality, such as isort, pyupgrade, flake8, and pydocstyle. However, I’ve recently discovered a powerful new tool called Ruff), an extremely fast Python linter written in Rust. Ruff is not only capable of replacing all these tools but also executes much faster, which significantly improves the development workflow.

Ruff offers an impressive range of features and performance enhancements. Some of its standout features include:

10-100x faster than existing linters
Over 500 built-in rules
Autofix support for automatic error correction
Built-in caching to avoid re-analyzing unchanged files
First-party editor integrations for VS Code and more

Moreover, Ruff has gained widespread adoption in the Python community and is used in major open-source projects like Apache Airflow, FastAPI, Hugging Face, Pandas, and SciPy. The tool is backed by Astral, which provides active development and support.

One of the best aspects of Ruff is the native VS Code extension, which continuously scans your code and can fix problems as you write. This seamless integration makes it an indispensable part of any Python development workflow.

To install Ruff, simply run the following command:

pip install ruff

To use Ruff in your project, run the following command in the terminal:

ruff your_file.py

For the best experience, I highly recommend using Ruff in conjunction with pre-commit, as mentioned earlier. This ensures that your code is always linted and formatted before committing, maintaining a consistent and high-quality codebase.

In conclusion, Ruff is an incredibly fast and powerful Python linter that streamlines the development process by consolidating multiple tools into a single, efficient package. By adopting Ruff and integrating it with pre-commit, you can enjoy a more productive and enjoyable Python development experience.

🔍 5. Mypy: static type checking for Python (find bugs before they happen) #

As developers, we’re always looking for ways to improve the quality of our code and minimize the time spent on debugging. This is where Mypy comes in. Mypy is a powerful static type checker for Python, designed to catch potential runtime errors before they occur. By using Mypy, you can ensure that your code adheres to type hints and that it runs smoothly without unexpected issues.

Mypy offers several advantages to Python developers, including:

Early detection of potential type errors, preventing many common bugs
Improved code readability and self-documentation through type annotations
Easier refactoring and code maintenance, as type annotations provide clear contracts between functions and modules
Better collaboration and communication within teams, since type annotations make the code’s intent and expectations more explicit

Adding Mypy to an existing project may initially seem time-consuming and frustrating, as it might flag numerous issues that require attention. However, once you’ve addressed these concerns and properly set up Mypy, the benefits far outweigh the initial effort. In fact, the time you invest in fixing type-related issues will quickly be recovered as Mypy helps you prevent bugs and reduce debugging time.

For a long time, I too ignored Mypy and only typed my code without actually checking it with the tool. But after truly embracing Mypy and integrating it into my development process, I can confidently say that I will never go back. The value it brings to the table in terms of code quality, readability, and reliability is simply too great to ignore.

By proactively identifying and resolving type-related issues, Mypy not only saves you precious debugging time but also enhances the overall quality of your codebase. As you continue to rely on Mypy, you’ll find that it becomes an indispensable part of your Python development toolkit, ensuring that your projects remain robust and maintainable.

To start using Mypy in your project, first install it with the following command:

pip install mypy

Then, you can run Mypy on your Python files by executing the following command in your terminal:

mypy your_file.py

For even better integration, you can add Mypy as a pre-commit hook, ensuring that your code is always checked for type consistency before being committed. This further strengthens the code quality and helps prevent potential runtime errors.

In summary, incorporating Mypy into your Python development workflow adds an extra layer of safety and clarity, making it easier to write high-quality, reliable code. By combining Mypy with other tools like Ruff and pre-commit, you can create a robust development environment that promotes productivity and code quality.

🧪 6. Nox and pytest for testing: a powerful combination #

When developing software, it’s essential to ensure that your code is reliable and functions as expected. The key to achieving this goal is writing thorough tests, which not only help you identify issues early on but also prevent regressions in the future. While it’s often tempting to dive headfirst into coding, taking a step back and first writing tests for your solution can lead to more efficient and effective development. Even if this approach doesn’t come naturally, it’s crucial to write tests for every problem you encounter to keep your codebase stable and reliable.

In the realm of Python testing, Nox and pytest stand out as powerful tools that can greatly enhance your testing process. Nox is a versatile automation tool that simplifies running tests in multiple virtual environments, while pytest is a popular and feature-rich testing framework for Python. Together, these tools provide a formidable testing environment that simplifies test management and execution.

In the past, you may have used Tox, a tool that manages test environments with a text-based configuration file (e.g., in setup.cfg or pyproject.toml). While Tox has served developers well for many years, including myself, Nox offers a more flexible alternative. Instead of relying on a text-based configuration, Nox takes advantage of a Python configuration file, providing virtually limitless configurability. This added flexibility makes it easy to create complex test matrices with different versions and dependencies, and even accommodate special conditions using simple if statements. After happily using Tox for years, I discovered Nox and found that it elevated my testing workflow to a whole new level.

To get started with Nox and pytest, create a basic nox.py file and a sample test file for pytest. Here’s an example nox.py configuration:

import nox

@nox.session(python=["3.7", "3.8", "3.9"])
def tests(session):
 session.install("-r", "requirements.txt")
 session.install("-r", "test-requirements.txt")
 session.run("pytest")

And an example test file for pytest:

import pytest

def test_addition():
 assert 1 + 1 == 2

def test_subtraction():
 assert 3 - 1 == 2

Beyond basic testing functionality, pytest boasts powerful features such as fixtures, mocking and patching, and parameterization. Pytest fixtures enable you to create reusable resources for your tests, while mocking and patching allow you to replace parts of your system with fake objects, isolating your tests from external dependencies. Parameterization, implemented using pytest.mark.parametrize, enables running the same test with multiple sets of inputs and expected outputs.

In conclusion, leveraging Nox and pytest for testing offers numerous advantages for developers who strive to improve code reliability and automate their testing workflows. By harnessing Nox’s exceptional configurability and pytest’s extensive testing features, you’ll establish a robust testing environment that bolsters code quality and ensures optimal performance.

🏷️ 7. Versioningit: version management with Git tags #

(Optional, only related when making a Python package)

For developers seeking an automated and customizable package versioning solution, Versioningit offers a powerful yet flexible approach. It is a setuptools plugin that automatically determines your package’s version based on your version control repository’s tags. The real advantage of Versioningit lies in its ability to customize the version format and even override separate functions used for version extraction and calculation.

Versioningit makes your release workflow extremely simple, especially if you have set up an automated build and twine PyPI upload pipeline. To create a new release, you only need to tag a version, and then click on the “Release” button in GitHub.

One of the major advantages of Versioningit is its minimal boilerplate code compared to other tools like Versioneer. Additionally, the Python __version__ string works seamlessly with editable installs (pip install -e .), unlike setuptools_scm, which is a common issue faced by developers.

Over the years, I have explored many options for package versioning, including Versioneer, Miniver, setuptools_scm, bumpversion (or bump2version), and manually setting everything. Versioningit stands out due to its simplicity, customization options, and compatibility with various workflows.

Some key features of Versioningit include:

Support for Git, modern Git archives, and Mercurial
Customizable version formatting using template strings
Optional writing of the final version and other details to a file for loading at runtime
Custom setuptools commands for inserting the final version and other details into a source file at build time
Customizable functions for VCS querying, tag-to-version calculation, version bumping, version formatting, and writing the version to a file

To use Versioningit in your project, simply add it to your project’s pyproject.toml file in the build-system.requires key. Then, create a [tool.versioningit] table in your pyproject.toml file. You can get up and running with just the minimal configuration - an empty table.

Once you have a [tool.versioningit] table in your pyproject.toml and your repository has at least one tag, building your project with setuptools will automatically set your project’s version based on the latest tag in your Git repository. With Versioningit, you can customize the version format using placeholder strings, making it adaptable to your project’s specific needs.

In summary, Versioningit streamlines the package versioning process and simplifies the release workflow. By automating package versioning based on version control repository tags and providing extensive customization options, it helps make the management of package versions more efficient and less error-prone.

📝 8. Pyproject.toml and PEP 621: Configuration Consolidation #

The pyproject.toml file plays a crucial role in consolidating configurations and setup for various tools in a Python project, such as Black, Ruff, Mypy, Versioningit, Nox, and pytest. This adherence to PEP 621 standards streamlines the development process by providing a single source of truth for multiple tools, eliminating the need for additional configuration files like setup.cfg or setup.py.

By specifying packaging details directly in the pyproject.toml file, you can efficiently manage your project’s dependencies and metadata. For example, the Adaptive Scheduler package demonstrates this approach with a comprehensive pyproject.toml file containing all the necessary configurations.

(click to unfold):

[build-system]
build-backend = "setuptools.build_meta"
requires = ["setuptools", "wheel", "versioningit"]

[project]
name = "adaptive_scheduler"
description = "Run many `adaptive.Learner`s on many cores (>10k) using `mpi4py.futures`, `ipyparallel`, `dask-mpi`, or `process-pool`."
requires-python = ">=3.8"
dynamic = ["version"]
maintainers = [{ name = "Bas Nijholt", email = "bas@nijho.lt" }]
license = { text = "BSD-3" }
classifiers = [
 "Development Status :: 2 - Pre-Alpha",
 "Intended Audience :: Developers",
 "Intended Audience :: Science/Research",
 "License :: OSI Approved :: BSD License",
 "Operating System :: OS Independent",
 "Programming Language :: Python",
 "Programming Language :: Python :: 3",
 "Programming Language :: Python :: 3.8",
 "Programming Language :: Python :: 3.9",
 "Programming Language :: Python :: 3.10",
 "Programming Language :: Python :: 3.11",
 "Topic :: Scientific/Engineering",
 "Topic :: System :: Distributed Computing",
]
dependencies = [
 "adaptive >= 0.14.1",
 "cloudpickle",
 "dill",
 "ipyparallel",
 "ipywidgets",
 "itables",
 "jinja2",
 "loky",
 "numpy",
 "pandas",
 "psutil",
 "pyarrow",
 "pyzmq",
 "rich",
 "structlog",
 "tinydb",
 "toolz",
 "tqdm",
 "versioningit",
]
[project.optional-dependencies]
all = ["dask-mpi", "mpi4py"]
test = ["pytest", "pytest-asyncio", "coverage", "pytest-cov"]
docs = [
 "myst-nb",
 "sphinx_fontawesome",
 "sphinx",
 "furo",
 "myst-parser",
 "emoji",
]
[project.urls]
homepage = "https://adaptive-scheduler.readthedocs.io/"
documentation = "https://adaptive-scheduler.readthedocs.io/"
repository = "https://github.com/basnijholt/adaptive-scheduler"

[project.readme]
content-type = "text/x-rst"
file = "README.rst"

[project.scripts]
adaptive-scheduler-launcher = "adaptive_scheduler._server_support.launcher:main"

[tool.versioningit]

[tool.versioningit.onbuild]
build-file = "adaptive_scheduler/_version.py"
source-file = "adaptive_scheduler/_version.py"

[tool.setuptools.packages.find]
include = ["adaptive_scheduler.*", "adaptive_scheduler"]

[tool.pytest.ini_options]
addopts = """
 -vvv
 --cov=adaptive_scheduler
 --cov-report term
 --cov-report html
 --cov-report xml
 --cov-fail-under=35
 --asyncio-mode=auto
"""

[tool.coverage.report]
exclude_lines = [
 "pragma: no cover",
 "raise NotImplementedError",
 "if TYPE_CHECKING:",
 "if __name__ == .__main__.:",
]

[tool.black]
line_length = 88

[tool.ruff]
line-length = 150
target-version = "py38"
select = ["ALL"]
ignore = [
 "T20", # flake8-print
 "ANN101", # Missing type annotation for {name} in method
 "S101", # Use of assert detected
 "PD901", # df is a bad variable name. Be kinder to your future self.
 "ANN401", # Dynamically typed expressions (typing.Any) are disallowed in {name}
 "D402", # First line should not be the function's signature
 "PLW0603", # Using the global statement to update `X` is discouraged
 "D401", # First line of docstring should be in imperative mood
 "SLF001", # Private member accessed
]

[tool.ruff.per-file-ignores]
"tests/*" = ["SLF001"]
"tests/test_examples.py" = ["E501"]
".github/*" = ["INP001"]

[tool.ruff.mccabe]
max-complexity = 18

[tool.mypy]
python_version = "3.8"

(from here)

As seen in the example, the pyproject.toml file includes details about the build system, project metadata, dependencies, optional dependencies, URLs, and configurations for various tools such as Versioningit, setuptools, pytest, coverage, Black, Ruff, and Mypy. By consolidating these configurations, you can maintain a more organized and maintainable project, making it easier to understand and update settings for different tools.

In summary, the pyproject.toml file and adherence to PEP 621 provide a unified approach to configuring and setting up your Python project, making it easier to manage dependencies, metadata, and tool-specific settings. This streamlined process ultimately leads to a more efficient and maintainable development workflow.

🌐 9. GitHub Actions CI Matrix: Testing on Multiple Platforms and Auto Publishing to PyPI #

GitHub Actions is an excellent tool for automating workflows and improving code quality through continuous integration (CI). By using a CI matrix, you can test your code on multiple platforms and Python versions, ensuring that your package remains compatible and stable across different environments.

To set up a .github/workflows/nox.yaml file for GitHub Actions, you can use the following simplified example:

name: nox

on:
 pull_request:
 push:
 branches: [main]

jobs:
 test:
 runs-on: ${{ matrix.platform }}
 strategy:
 fail-fast: false
 matrix:
 platform: [ubuntu-latest, macos-latest, windows-latest]
 python-version: ["3.8", "3.9", "3.10", "3.11"]

 steps:
 - uses: actions/checkout@v2
 - name: Set up Python ${{ matrix.python-version }}
 uses: actions/setup-python@v2
 with:
 python-version: ${{ matrix.python-version }}
 - name: Install dependencies
 run: pip install nox
 - name: Test with nox
 run: nox -e py${{ matrix.python-version }}

This configuration file specifies the platforms and Python versions for testing, as well as the steps to set up the environment, install dependencies, and run tests using nox. With this simple configuration, you set up tests on MacOS, Windows, Linux, and multiple Python versions, ensuring that your package remains compatible across different environments.

Another essential part of the CI/CD process is deploying your Python package. You can use the .github/workflows/publish-package.yaml file to automate the package deployment to PyPI whenever a new release is published:

name: Upload Python Package

on:
 release:
 types: [published]

jobs:
 deploy:

 runs-on: ubuntu-latest

 steps:
 - uses: actions/checkout@v2
 - name: Set up Python
 uses: actions/setup-python@v2
 with:
 python-version: '3.x'
 - name: Install dependencies
 run: |
 python -m pip install --upgrade pip
 pip install setuptools wheel twine build
 - name: Build and publish
 env:
 TWINE_USERNAME: __token__
 TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
 run: |
 python -m build
 twine upload dist/*

This workflow sets up Python, installs necessary dependencies, builds the package, and publishes it to PyPI using Twine. The process integrates seamlessly with versioningit, ensuring that the published package has the correct version number based on the git history.

In summary, leveraging GitHub Actions for continuous integration and automated workflows enhances code quality and reliability, while also simplifying the development and deployment processes. By testing across various platforms and Python versions, and automating package deployment, you can be confident that your package is well-maintained and accessible to users.

📚 10. Read the Docs, Sphinx, MyST-NB, and Jupytext notebooks for documentation #

Documentation is crucial for any software project, as it helps users understand how to use the package and provides guidance for contributors. Read the Docs, Sphinx, MyST-NB, and Jupytext notebooks are powerful tools that, when combined, facilitate the creation and maintenance of high-quality documentation.

tl;dr: check out the Adaptive documentation for an example of how to use these tools to create a comprehensive documentation website.

Read the Docs is a documentation hosting platform that automatically builds, version controls, and hosts your documentation for free. It integrates well with Sphinx and GitHub, allowing your documentation to be updated whenever you push changes to your repository.

Sphinx is a documentation generator that can transform reStructuredText files, MyST files, or Jupyter notebooks into various output formats, such as HTML, LaTeX, or PDF. It is highly extensible, supporting custom themes and plugins, and can automatically generate API documentation from your Python code.

MyST-NB is an extension to Sphinx that enables it to parse Jupyter notebooks and execute the code cells during the build process. It uses the MyST (short for Markedly Structured Text) markdown parser, which adds support for Sphinx roles and directives, making it a powerful alternative to reStructuredText.

Jupytext notebooks is a Jupyter extension that enables you to save Jupyter notebooks in Markdown format (or other text-based formats) instead of the default JSON format. By using Jupytext notebooks, you can store your code, explanations, and visualizations as plain text, which is easier to version control and can be seamlessly integrated with MyST-NB and Sphinx.

With MyST-NB and Jupytext, you can write your documentation using Jupyter notebooks in Markdown format. This approach combines the benefits of Jupyter notebooks, such as interactive code execution and rich output, with the simplicity of Markdown and the powerful features of Sphinx. The result is a highly readable, user-friendly, and maintainable documentation that caters to both users and developers.

To get started with MyST-NB, you’ll need to install it using pip:

pip install myst-nb

Next, configure your Sphinx project to use MyST-NB by adding the following lines to your conf.py file:

extensions = [
 "myst_nb",
]

Now, Sphinx will be able to parse and execute your Jupyter notebooks during the documentation build process, integrating them seamlessly with your existing documentation.

In summary, using Read the Docs, Sphinx, MyST-NB, and Jupytext notebooks for your documentation enables you to create high-quality, interactive, and easily maintainable documentation that benefits your project’s users and contributors. This combination of tools ensures that your documentation remains up-to-date, easily navigable, and engaging, ultimately enhancing the overall experience for your project’s audience.

For a full example, see how I setup Adaptive’s documentation using Sphinx, MyST-NB, and Jupytext notebooks. readthedocs.yaml, docs/source/conf.py, and here is an example notebook that is used in the documentation: docs/source/tutorial/tutorial.Learner1D.md

🎉 11. Conclusion #

In conclusion, incorporating these powerful tools into your Python development workflow can significantly enhance your productivity and code quality. By adopting pre-commit, Black, Ruff, Mypy, Versioningit, Pyproject.toml with PEP 621, Nox, pytest, GitHub Actions CI matrix, and Read the Docs, Sphinx, MyST-NB, and Jupytext notebooks for documentation, you create a streamlined, efficient, and reliable development environment.

These tools help maintain code consistency, catch issues early, automate package versioning, simplify testing, consolidate configurations, and create high-quality documentation. By integrating them into your projects, you can focus on writing great code while ensuring that your work remains robust, maintainable, and accessible to users and contributors alike.

Don’t hesitate to explore these tools and incorporate them into your Python development toolkit. They can transform your development experience, making it more enjoyable and efficient, ultimately leading to higher-quality projects and happier developers. Happy coding!

My VS Code setup: extensions and shortcuts ⚡

Sun, 16 Apr 2023 00:00:00 +0000

Visual Studio Code, or VSCode, has rapidly become one of the most popular code editors available today, and for good reason. With a vast amount of development activity behind it, VSCode is a powerful and extensible platform that allows users to customize it to their needs through a wide variety of extensions. As a long-time Sublime Text user, I was initially skeptical about making the switch due to concerns about performance. However, as I spent more time using VSCode, I became convinced of its many benefits and have since made it my go-to editor for all my development needs, particularly for Python.

In this blog post, I will share my personal setup for turbocharging Python development in VSCode, including my favorite extensions and most-used keystrokes. By tailoring your editor to your specific requirements and preferences, you can maximize productivity and minimize keystrokes, making your development experience as smooth and efficient as possible.

Table of contents

My most common Shortcuts #

Personally, I use the Sublime Keymap extension to add Sublime Text keybindings to VSCode.

It is a valuable extension for those who are transitioning from Sublime Text to Visual Studio Code or simply prefer Sublime Text’s keybindings. This extension replicates Sublime Text’s keyboard shortcuts in VSCode, allowing you to maintain your productivity and muscle memory.

Here are my commonly used shortcuts when using the Sublime Keymap extension and the default VSCode keybindings (if missing both are the same):

Keybinding (Sublime)	Keybinding (VS Code)	Description
Command + Shift + P (Mac) / Ctrl + Shift + P (Windows)	same	Open the command palette
Command + P (Mac) / Ctrl + P (Windows)	same	Quick file navigation
Command + D (Mac) / Ctrl + D (Windows)	same	Select the next occurrence of the current word
Command + U (Mac) / Ctrl + U (Windows)	same	Undo the last “select next word” operation
Alt + up/down arrow	same	Move the selected lines up or down
Alt + Shift + up/down arrows	same	Duplicate the selected lines above or below
Command + Shift + L (Mac) / Ctrl + Shift + L (Windows)	Shift + Alt + L	Place a cursor at the end of all selected lines
Control + - (minus)	same	Navigate to the previous location in the editor
Command + T (Mac) / Ctrl + T (Windows)	Command + P (Mac) / Control + P (Windows)	Browse files in the workspace
Command + R (Mac) / Ctrl + R (Windows)	Command + Shift + O (Mac) / Ctrl + Shift + O (Windows)	Open the command palette and search for definitions in the file (bonus, add a `:`, to get `@:` to group by functions, methods, variables, etc.)
Command + B (Mac) / Ctrl + B (Windows)	same	Toggle the visibility of the sidebar (explorer, search, etc.)
Command + Shift + F (Mac) / Ctrl + Shift + F (Windows)	same	Search across all files in your workspace
Command + Shift + E (Mac) / Ctrl + Shift + E (Windows)	same	Open the file explorer
Control + Space	same	Open the autocomplete menu
Command + Mouse click or F12	same	Go to the definition of the selected word
Command + I	same	Open GitHub Copilot prompt inline
Command + Shift + I	same	Open GitHub Copilot prompt in sidebar
Shift + Alt + F	same	Autoformat
Command + Control + G	Command + Shift + L (Mac) / Ctrl + Shift + L (Windows)	Select all occurrences of current word
F2	same	Rename symbol
Ctrl + `	same	Open the integrated terminal
Alt + Z	same	Toggle word wrap

My favorite extensions #

I have ranked my top 8 extensions, which I would recommend to anyone who is looking to improve their productivity and efficiency in VSCode.

1. GitHub Copilot #

GitHub Copilot is an AI-powered code completion extension that provides seamless integration with the Copilot service, helping you write code faster and smarter.

Use code --install-extension GitHub.copilot to install the GitHub Copilot extension (docs)

2. GitLens #

GitLens supercharges the built-in Git support in VSCode, providing useful insights into your code history and changes, including advanced blame annotations, code lens, and more.

Use code --install-extension eamodio.gitlens to install the GitLens extension (docs)

3. Python and Pylance #

These extensions offer comprehensive support for Python development, with features like IntelliSense, linting, debugging, and code navigation. Pylance enhances Python support with improved code completion, type checking, and language features.

Use code --install-extension ms-python.python to install the Python extension (docs)
Use code --install-extension ms-python.vscode-pylance to install the Pylance extension (docs)

4. Jupyter #

The Jupyter extensions enable you to work with Jupyter Notebooks in VSCode, with support for running cells, debugging, and more. Jupyter Keymap adds customizable keyboard shortcuts for Jupyter commands.

Use code --install-extension ms-toolsai.jupyter to install the Jupyter extension (docs)

5. Sublime Keybindings #

Sublime Keybindings adds keybindings from Sublime Text to VSCode, making it easier for developers familiar with Sublime Text to transition to VSCode.

Use code --install-extension ms-vscode.sublime-keybindings to install the Sublime Keybindings extension (docs)

6. Remote Containers, SSH, and Remote Extension Pack #

These extensions provide support for working with remote development environments in VSCode, such as developing inside a container or connecting to remote machines via SSH. The Extension Pack bundles all the remote development extensions for convenience.

Use code --install-extension ms-vscode-remote.remote-ssh-edit to install the Remote SSH Edit extension (docs)
Use code --install-extension ms-vscode-remote.vscode-remote-extensionpack to install the Remote Extension Pack (docs)
Use code --install-extension ms-vscode.remote-explorer to install the Remote Explorer extension (docs)
Use code --install-extension ms-vscode.remote-repositories to install the Remote Repositories extension (docs)

7. Indent Rainbow #

Indent Rainbow is a VSCode extension that colorizes indentation levels in your code, making it easier to visualize and navigate complex code structures.

Use code --install-extension oderwat.indent-rainbow to install the Indent Rainbow extension (docs)

8. Code Spell Checker #

Code Spell Checker is a helpful extension that checks your code and comments for spelling errors, helping you maintain clean and professional code.

Use code --install-extension streetsidesoftware.code-spell-checker to install the Code Spell Checker extension (docs)

Ruff #

Ruff is a Visual Studio Code extension that provides support for the Ruff linter, an extremely fast Python linter written in Rust. It offers numerous features such as built-in caching, autofix support, and a comprehensive set of built-in rules. Ruff aims to replace multiple tools like Flake8, isort, pydocstyle, yesqa, eradicate, pyupgrade, and autoflake, while executing much faster than any individual tool.

Use code --install-extension charliermarsh.ruff to install the Ruff extension (docs)

GitHub Codespaces, RemoteHub, and Pull Request #

These GitHub extensions provide seamless integration with various GitHub services, including Codespaces (cloud-based development environments), RemoteHub (browse remote repositories), and Pull Request management.

Use code --install-extension GitHub.codespaces to install the GitHub Codespaces extension (docs)
Use code --install-extension GitHub.remotehub to install the GitHub RemoteHub extension (docs)
Use code --install-extension GitHub.vscode-pull-request-github to install the GitHub Pull Request extension (docs)

Rainbow CSV #

Rainbow CSV adds syntax highlighting for CSV and TSV files in VSCode, making it easier to read and analyze data by color-coding columns.

Use code --install-extension mechatroner.rainbow-csv to install the Rainbow CSV extension (docs)

Better Comments #

Better Comments is a VSCode extension that helps improve the readability of your code comments by adding color and style to different types of comments, such as TODOs, highlights, questions, and alerts.

Use code --install-extension aaron-bond.better-comments to install the Better Comments extension (docs)

Markdown Preview Enhanced #

Markdown Preview Enhanced is a feature-rich extension that provides a real-time preview of your Markdown files, supporting various Markdown flavors, interactive diagrams, and more.

Use code --install-extension shd101wyy.markdown-preview-enhanced to install the Markdown Preview Enhanced extension (docs)

Markdown All in One #

Markdown All in One is a comprehensive extension that provides a range of features for working with Markdown files in VSCode, including syntax highlighting, auto-completion, table of contents, and more.

Use code --install-extension yzhang.markdown-all-in-one to install the Markdown All in One extension (docs)

WakaTime #

WakaTime is an open source VS Code plugin for metrics, insights, and time tracking automatically generated from your programming activity. This service will keep a summary of how much time you spend in which project and which programming language.

Use code --install-extension WakaTime.vscode-wakatime to install the WakaTime extension (docs)

Other extensions I use #

The following extensions are not as essential as the ones listed above, but I still find them useful for various tasks.

LaTeX Workshop #

LaTeX Workshop is a comprehensive extension for working with LaTeX documents in VSCode, featuring syntax highlighting, building and previewing, IntelliSense, and more.

Use code --install-extension James-Yu.latex-workshop to install the LaTeX Workshop extension (docs)

Visual Studio Live Share is a real-time collaboration extension that allows you to share your workspace with others, enabling pair programming, code reviews, and collaborative debugging.

Use code --install-extension ms-vsliveshare.vsliveshare to install the Live Share extension (docs)

Azure Account and Repos #

These extensions offer a range of Azure-related functionality, including managing your Azure account, working with Azure Repos, exploring remote resources, and browsing remote Git repositories.

Use code --install-extension ms-vscode.azure-account to install the Azure Account extension (docs)
Use code --install-extension ms-vscode.azure-repos to install the Azure Repos extension (docs)

CodeSnap #

CodeSnap is a handy extension for creating beautiful code screenshots directly from your editor, making it easier to share code snippets on social media, blog posts, or documentation.

Use code --install-extension adpyke.codesnap to install the CodeSnap extension (docs)

Micromamba #

The Micromamba extension for VSCode integrates the Micromamba package manager, making it easier to manage Conda environments and packages within the editor.

Use code --install-extension corker.vscode-micromamba to install the Micromamba extension (docs)

Markdownlint #

Markdownlint is a VSCode extension that provides linting and style-checking for Markdown files, ensuring consistent and clean Markdown content.

Use code --install-extension DavidAnson.vscode-markdownlint to install the Markdownlint extension (docs)

Prettier #

Prettier is a powerful code formatter that supports multiple languages, including JavaScript, TypeScript, HTML, CSS, and more. It enforces a consistent code style across your project.

Use code --install-extension esbenp.prettier-vscode to install the Prettier extension (docs)

Code Runner #

Code Runner is a versatile extension that enables you to quickly run code snippets or whole files for multiple programming languages within VSCode, without the need to switch to an external terminal.

Use code --install-extension formulahendry.code-runner to install the Code Runner extension (docs)

Go #

The Go extension by the Go team provides rich language support for the Go programming language, with features like IntelliSense, debugging, linting, and code navigation.

Use code --install-extension golang.go to install the Go extension (docs)

Home Assistant #

The Home Assistant extension for VSCode provides integration with Home Assistant configuration files, offering syntax highlighting, auto-completion, and validation.

Use code --install-extension keesschollaart.vscode-home-assistant to install the Home Assistant extension (docs)

Azure Pipelines, Resource Groups, Storage, and Terraform #

These Microsoft Azure extensions provide powerful integrations with various Azure services, allowing you to manage pipelines, resource groups, storage, and Terraform configurations directly within VSCode.

Use code --install-extension ms-azure-devops.azure-pipelines to install the Azure Pipelines extension (docs)
Use code --install-extension ms-azuretools.vscode-azureresourcegroups to install the Azure Resource Groups extension (docs)
Use code --install-extension ms-azuretools.vscode-azurestorage to install the Azure Storage extension (docs)
Use code --install-extension ms-azuretools.vscode-azureterraform to install the Azure Terraform extension (docs)

Docker #

The Docker extension adds rich support for working with Docker containers and images in VSCode, including building, managing, and deploying containerized applications.

Use code --install-extension ms-azuretools.vscode-docker to install the Docker extension (docs)

AutoDocstring #

AutoDocstring is a helpful extension that automatically generates docstrings for Python functions and classes, following popular docstring formats like Google, NumPy, and reStructuredText.

Use code --install-extension njpwerner.autodocstring to install the AutoDocstring extension (docs)

XML and YAML #

These extensions by Red Hat provide rich language support for XML and YAML, including syntax highlighting, validation, code navigation, and more.

Use code --install-extension redhat.vscode-xml to install the XML extension (docs)
Use code --install-extension redhat.vscode-yaml to install the YAML extension (docs)

Rust Analyzer #

Rust Analyzer is a powerful language server for the Rust programming language, offering features like syntax highlighting, code navigation, and auto-completion.

Use code --install-extension rust-lang.rust-analyzer to install the Rust Analyzer extension (docs)

Even Better TOML #

Even Better TOML is a VSCode extension that provides syntax highlighting, validation, and auto-completion for TOML (Tom’s Obvious, Minimal Language) configuration files.

Terrastruct #

Terrastruct is a VSCode extension that helps you visualize your Terraform dependency graphs as interactive diagrams, making it easier to understand complex infrastructure-as-code projects.

Use code --install-extension Terrastruct.d2 to install the Terrastruct extension (docs)

PDF #

The PDF extension allows you to view and manage PDF files directly within VSCode, with support for zooming, rotating, and searching text.

Use code --install-extension tomoki1207.pdf to install the PDF extension (docs)

LTeX #

LTeX is a grammar and spell checker extension for LaTeX, Markdown, and other markup languages, with support for multiple languages and customizable rules.

Use code --install-extension valentjn.vscode-ltex to install the LTeX extension (docs)

IntelliCode API Usage Examples and IntelliCode #

These extensions by the Visual Studio Expt Team provide AI-powered code completion and code examples, helping you write code faster and with fewer errors.

Use code --install-extension VisualStudioExptTeam.intellicode-api-usage-examples to install the IntelliCode API Usage Examples extension (docs)
Use code --install-extension VisualStudioExptTeam.vscodeintellicode to install the IntelliCode extension (docs)

vscode-icons #

vscode-icons is a popular extension that adds file icons to VSCode, making it easier to identify file types in the file explorer.

Use code --install-extension vscode-icons-team.vscode-icons to install the vscode-icons extension (docs)

Developer-Tools | Bas Nijholt

Python environments that stuck: micromamba and uv 🐍

1. Introduction 🚀 #

2. The Alternatives 🌟 #

🐍 Pyenv #

📦 Pipenv #

🌐 Conda #

🚀 Mamba #

🌌 Micromamba #

🐳 Docker #

🏞️ Venv #

🌐 Virtualenv #

🍺 Homebrew #

💻 System package managers #

🌟 Pixi #

⚡ uv #

3. Conclusion 🏁 #

4. Further Reading 📚 #

fileup 📤

📖 Origin Story #

🔧 Technical Highlights #

📊 Impact #

💡 Lessons Learned #

clip-files 📋

📖 Origin Story #

🔧 Technical Highlights #

📊 Impact #

🎯 Challenges and Solutions #

💡 Lessons Learned #

markdown-code-runner 📝

📖 Origin Story #

🔧 Technical Highlights #

📊 Impact #

🎯 Challenges and Solutions #

💡 Lessons Learned #

Discovering Git worktrees: a handy tool for multitasking 📚

What is a Git Worktree?

Benefits of Git Worktrees

Quick Commands

Conclusion

My favorite tools that keep my Python projects sane 🧰

🌟 1. Introduction #

🛠️ 2. Pre-commit #

🎨 3. Black: auto-formatting for Python #

🚀 4. Ruff: the fastest Python linter and auto-formatter #

🔍 5. Mypy: static type checking for Python (find bugs before they happen) #

🧪 6. Nox and pytest for testing: a powerful combination #

🏷️ 7. Versioningit: version management with Git tags #

📝 8. Pyproject.toml and PEP 621: Configuration Consolidation #

🌐 9. GitHub Actions CI Matrix: Testing on Multiple Platforms and Auto Publishing to PyPI #

📚 10. Read the Docs, Sphinx, MyST-NB, and Jupytext notebooks for documentation #

🎉 11. Conclusion #

My VS Code setup: extensions and shortcuts ⚡

My most common Shortcuts #

My favorite extensions #

1. GitHub Copilot #

2. GitLens #

3. Python and Pylance #

4. Jupyter #

5. Sublime Keybindings #

6. Remote Containers, SSH, and Remote Extension Pack #

7. Indent Rainbow #

8. Code Spell Checker #

Ruff #

GitHub Codespaces, RemoteHub, and Pull Request #

Rainbow CSV #

Better Comments #

Markdown Preview Enhanced #

Markdown All in One #

WakaTime #

Other extensions I use #

LaTeX Workshop #

Live Share #

Azure Account and Repos #

CodeSnap #

Micromamba #

Markdownlint #

Prettier #

Code Runner #

Go #