DEV Community: xrc

Easily Set Up Your Usual tmux Pane Layout

xrc — Sun, 15 Jun 2025 12:17:42 +0000

Overview

Every time I start new development work, I have to manually split tmux panes,
navigate to the necessary directories in each pane, and execute commands.
This got tedious, so I created a tool called tsps to eliminate this repetitive work.

https://github.com/yyossy5/tsps

https://crates.io/crates/tsps

tsps Demo

I've prepared a demo video since seeing it in action is the quickest way to understand:

Key Features

Simple Operation: Create multiple panes with a single command
Automatic Directory Navigation: Move all panes to a specified directory
Automatic Command Execution: Run arbitrary commands in each pane automatically
YAML Configuration: Reusable custom layout configurations
Focus Control: Specify which pane gets initial focus

Installation

I recommend installing via Cargo:

cargo install tsps

For macOS users without Cargo, I've also prepared pre-built binaries in the Releases.
Details are available in the README.

Basic Usage

Simple Pane Splitting

Create a specified number of panes, all navigated to the specified directory:

# Create 4 panes, all cd'd to the current directory
tsps 4 .

# Create 3 panes, all cd'd to a specific project directory
tsps 3 /path/to/project

Using YAML Configuration Files

For even more convenience, use YAML files:

tsps -l config.yaml -d /path/to/project

YAML Configuration Files

I expect that using configuration files will be the most common use case.

Simple Example

# Simple 2-pane layout
workspace:
  name: "simple"
  description: "2-pane layout with editor and terminal"
  directory: "."

panes:
  - id: "editor"
    commands:
      - "nvim ."
    focus: true

  - id: "terminal"
    split: "horizontal"

This configuration creates:

Editor pane (launches Neovim, has focus)
Terminal pane (positioned with horizontal split)

More Practical Example

# Development layout example
workspace:
  name: "dev"
  description: "4-pane layout for development"
  directory: "/Users/me/Projects/tsps"

panes:
  # Main editor (top-left)
  - id: "editor"
    commands:
      - "nvim ."
    focus: true

  # Claude Code (top-right, smaller)
  - id: "claude"
    split: "vertical"
    size: "38%"
    commands:
      - "claude"

  # General terminal (bottom-left)
  - id: "terminal"
    split: "horizontal"
    size: "30%"
    commands:
      - "ls -la"

  # Git operations (bottom-right, larger)
  - id: "git"
    split: "vertical"
    size: "60%"
    commands:
      - "lazygit"

This configuration creates:

editor pane: Opens the project in Neovim
claude pane: Vertical split, 38% size, launches Claude CLI
terminal pane: Horizontal split, 30% size, displays directory contents
git pane: Vertical split, 60% size, launches Lazygit

The result looks like this:

Configuration Options Details

Option	Description	Example
`name`	Workspace name	`"development"`
`description`	Description text	`"Development setup"`
`directory`	Working directory (can be overridden with -d option)	`"~/projects/myapp"`
`split`	Split direction	`"horizontal"` / `"vertical"`
`size`	Pane size (%)	`50`
`commands`	Array of commands to execute	`["git status", "npm start"]`
`focus`	Initial focus	`true` / `false`

Conclusion

If you use tmux and want to make your daily development workflow a bit easier, please give this tool a try.

Using uv Environment Kernels in Jupyter Notebook

xrc — Sat, 14 Jun 2025 05:25:42 +0000

Article Overview

This article describes how to add/remove kernels for uv virtual environments.

Assumed Scenario

There is a uv-managed Python repository called my-python-repo, and we want to create a kernel for this repository's library environment to work in Jupyter Notebook.

Kernel Addition Steps

1. Clone my-python-repo

First, let's get my-python-repo.

git clone git@xxx.org:myorg-dev/my-python-repo.git

2. Create Virtual Environment from uv.lock

After cd into the cloned my-python-repo, you can create a virtual environment based on uv.lock by running uv sync.

uv sync

This creates a venv virtual environment (.venv directory) based on uv.lock.
We just need to create a kernel linked to this virtual environment.

3. Add ipykernel to Virtual Environment for Jupyter Kernel Recognition

Jupyter requires ipykernel to recognize the virtual environment as a kernel.

uv add --dev ipykernel

4. Register Virtual Environment as Jupyter Kernel

As an example, we'll register a kernel with the name Python3.13.2-my-python-repo-new-feature.

uv run ipython kernel install --user --env VIRTUAL_ENV $(pwd)/.venv --name="Python3.13.2-my-python-repo-new-feature"

You can confirm it's been added by checking the kernel list with the following command:

jupyter kernelspec list

Check kernel.json and verify that the destinations of python and VIRTUAL_ENV are as expected.

The first element of argv points to python in .venv/bin
VIRTUAL_ENV points to the .venv created by uv

$ cat ~/.local/share/jupyter/kernel/python3.13.2-my-python-repo-new-feature/kernel.json
{
 "argv": [
  "/home/xxx/workspace/xxx_notebooks/my-python-repo/.venv/bin/python3",
  "-m",
  "ipykernel_launcher",
  "-f",
  "{connection_file}"
 ],
 "display_name": "Python3.13.2-my-python-repo-new-feature",
 "language": "python",
 "metadata": {
  "debugger": true
 },
 "env": {
  "VIRTUAL_ENV": "/home/xxx/workspace/xxx_notebooks/my-python-repo/.venv"
 }

5. Open Jupyter Notebook and Use the Kernel

When you open Jupyter Notebook, the kernel has been added, so select it and start working.

Kernel Removal Steps

To remove a kernel, do the following:

# Check kernel list
$ jupyter kernelspec list

# Remove myenv kernel
$ jupyter kernelspec uninstall myenv

How to Add Libraries in Kernels Linked to uv Virtual Environment

By running !uv add in a notebook cell as shown below, you can add libraries to the uv virtual environment and immediately import them.

!uv add requests

Alternatively, instead of from the notebook, you can go to the location where the uv virtual environment is in the terminal

uv add requests

and add normally like this, which will add the library to the kernel.
In this case too, you can immediately import it on the notebook side.

Summary

I think it's good to value environment reproducibility and utilize uv even in Jupyter Notebook.

References

https://docs.astral.sh/uv/guides/integration/jupyter/

Essential uv Usage for Daily Development

xrc — Sat, 14 Jun 2025 05:19:32 +0000

Article Overview

This article describes how to use uv, a Python project management tool.
I use uv for Python projects both at work and in personal projects, and have compiled the essentials I frequently use in daily development based on official documentation and my own experience.
The content is based on v0.6.14.
Since it has Stable status, I don't think the usage will change dramatically, but please refer to the official documentation for the latest information.

Main Things Managed by uv

Python project management can be done with uv alone, no other tools are needed.

Python version used in the project
Dependencies (complete environment reproduction possible with lock files)
Virtual environments

About Python Version Management

uv can manage Python itself and versions, claiming to be a replacement for pyenv.
As of v0.6.14, uv can manage Python versions per project, but it doesn't manage system-level Python and is not a complete replacement for pyenv (though I personally think pyenv is no longer needed since you basically don't need multiple system-level Pythons).
It plans to support system-level Python management in the future¹

About Lock Files

A lock file is a record file used for complete environment reproduction, and in uv, uv.lock is the lock file (this is not a concept originating from uv, but a concept adopted by package managers in other languages like npm).
It has the following characteristics:

Manages versions down to transitive dependencies
Cross-platform support
Git-managed and manual editing is prohibited ²

Unlike managing libraries with pip + requirements.txt, environment reproducibility is cross-platform.

Example of pandas in uv.lock:

[[package]]
name = "pandas"
version = "2.2.3"
source = { registry = "https://pypi.org/simple" }
dependencies = [
    { name = "numpy" },
    { name = "python-dateutil" },
    { name = "pytz" },
    { name = "tzdata" },
]
sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
wheels = [
    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 },
    { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 },
    { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 },
    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 },
    { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 },
    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 },
    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 },
    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 },
    { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 },
    { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 },
    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 },
    { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 },
    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 },
]

Virtual Environment

The virtual environment is not something unique to uv, it just uses venv.
(So it's possible to execute Python in the virtual environment by manually activating the venv environment and using the python command instead of the uv run described later, though this is not recommended.)

The Python version used will be the one specified in .python-version (at the time of virtual environment creation).

Comparison of Flow from Clone to Application Execution (Without uv / With uv)

Let me show examples of the flow after git clone of a uv-managed project, along with cases not using uv.

When managing with pyenv, pip + requirements.txt and using venv directly, it would be something like this:

# Clone repository
git clone xxx.git

# Specify Python version if .python-version is not committed to repository
pyenv local 3.13.2

# Create virtual environment with venv and install packages
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# Verify that python command points to .venv/bin/python and is the intended version
ls -l $(which python)
lrwxrwxrwx. 1 ec2-user ec2-user 48  Apr 11 02:24 /home/ec2-user/myproj/.venv/bin/python -> /home/ec2-user/.pyenv/versions/3.13.2/bin/python

# Execute
python example.py

This procedure has subtle traps.
If you don't specify the Python version with pyenv before creating the venv environment, you won't be able to use the Python version specified with pyenv local, or if you forget to activate the venv environment and run pip install, it will be installed globally on the system.

For uv-managed projects, it would be as follows:

# Clone repository
git clone xxx.git

# A venv virtual environment with libraries from uv.lock is automatically created
# using the Python version specified in .python-version,
# and example.py is executed within it
uv run example.py

Very simple, isn't it?

Usage

https://docs.astral.sh/uv/getting-started/features/

The official page above serves as a cheat sheet, so if you're stuck, run uv --help or refer to the above.

Initialize Project with uv

https://docs.astral.sh/uv/guides/projects/

Initialize a project for uv management with uv init.
main.py, pyproject.toml, .python-version, and README.md are created.

# Initialize as a project using Python 3.13.2
uv init -p 3.13.2

# Running the created main.py with uv run also creates virtual environment and uv.lock
uv run main.py

Python Management

https://docs.astral.sh/uv/concepts/python-versions/

Check Available/Installed Python Versions

uv python list

Output Example:

Installed versions show installation paths as follows:

$ uv python list
cpython-3.14.0a6-linux-x86_64-gnu                 <download available>
cpython-3.14.0a6+freethreaded-linux-x86_64-gnu    <download available>
cpython-3.13.3-linux-x86_64-gnu                   <download available>
cpython-3.13.3+freethreaded-linux-x86_64-gnu      <download available>
cpython-3.13.2-linux-x86_64-gnu                   /home/ec2-user/.local/share/uv/python/cpython-3.13.2-linux-x86_64-gnu/bin/python3.13
cpython-3.12.10-linux-x86_64-gnu                  <download available>
cpython-3.11.12-linux-x86_64-gnu                  <download available>
cpython-3.10.17-linux-x86_64-gnu                  <download available>
cpython-3.9.22-linux-x86_64-gnu                   <download available>
cpython-3.8.20-linux-x86_64-gnu                   <download available>
cpython-3.7.9-linux-x86_64-gnu                    <download available>

Install Python

uv python install allows you to install Python that can be used via uv.
This makes it possible to use installed Python versions in uv-managed projects.
(※However, even without pre-installation, Python is automatically installed when needed with default settings, so explicit pre-installation is not mandatory.)

# Example of installing 3.13
uv python install 3.13

Output example:

$ uv python install 3.13
Installed Python 3.13.2 in 1.89s
 + cpython-3.13.2-linux-x86_64-gnu

Note:

As of v0.6.14, Python installed this way cannot be called directly with the python command; you need to use uv run or manually create a virtual environment with uv venv, source .venv/bin/activate, and then use the python command (recommended is uv run described later).
https://docs.astral.sh/uv/guides/install-python/#getting-started

Permanently Change Python Version Used by `uv` Command

https://docs.astral.sh/uv/reference/cli/#uv-python-pin

uv python pin permanently changes the Python version used by the uv command.
(It rewrites .python-version.)

# Example of using 3.13.2
uv python pin 3.13.2

Dependency Management

Add/Update Dependencies

uv add³ performs the following:

Install in venv virtual environment
Add to dependencies in pyproject.toml
Update uv.lock

# Add latest version of requests package
uv add requests

# Specify version
uv add 'requests==2.31.0'

# Add git dependency
uv add git+https://github.com/psf/requests

# Migrate from requirements.txt
uv add -r requirements.txt -c constraints.txt
# If not using constraints.txt, use this
uv add -r requirements.txt

# Adding --dev makes it a development dependency
# (added to dev in [dependency-groups] of pyproject.toml).
# Example of adding moto needed only for testing as development dependency
uv add moto --dev

# Updates are also possible with uv add --upgrade
uv add requests --upgrade

Note:

If library dependencies conflict and cannot be resolved, an error occurs (for example, when you want to use pandas 2.2.3 but a dependency requires pandas < 2.0.0).
In such cases, you can use the --frozen flag of uv add to install while ignoring dependency conflicts.
However, since it's not written to uv.lock, if you use it, I recommend understanding the risks (possibility of losing consistency between library dependencies, possibility of errors related to libraries with conflicting versions, etc.).

Note:

When using uv add, not only the package you're trying to add but the entire project's dependencies are re-evaluated⁴.
Therefore, if something that failed dependency resolution but was forcibly added with --frozen is included in pyproject.toml dependencies, it will error even if there's no problem with what you're trying to uv add.
In such cases, you should first remove the problematic item with uv remove, then uv add what you want to add, and re-add the removed item with uv add --frozen.

Remove Dependencies

You can remove dependencies using uv remove⁵.

# Remove requests package from dependencies
uv remove requests

# Add --dev when removing development dependencies
uv remove moto --dev

Python Execution

https://docs.astral.sh/uv/guides/scripts/

Use the uv run command to execute Python in uv's virtual environment.
If they don't exist on first run, virtual environment and uv.lock are created.⁶

# Execute example.py in uv.lock's virtual environment
uv run example.py

# You can also explicitly specify Python version when running scripts
uv run --python 3.10 example.py

# To run python -m unittest test/unit/test_main.py with uv
uv run python -m unittest test/unit/test_main.py

By the way, adding the -v option displays uv's internal operations in logs, which is useful for troubleshooting.

Sync Virtual Environment State with `uv.lock`

https://docs.astral.sh/uv/concepts/projects/sync/#syncing-the-environment

uv sync can synchronize the virtual environment state with the contents of uv.lock.
Since using uv run guarantees that Python can be executed in the uv.lock environment⁷, there's basically no need to explicitly run uv sync, but if you want to manually activate and use the venv environment, you can synchronize the virtual environment state with the contents of uv.lock by running uv sync as follows:

uv sync
source .venv/bin/activate
flask run -p 3000
python example.py

Tool-Related

Run Tools Without Installing

https://docs.astral.sh/uv/guides/tools/#running-tools

The uvx command allows you to run tools without installing them.
(They are actually installed in a temporary environment for uvx)

# Example of running ruff check
uvx ruff

# Example of running with ruff 0.3.0
uvx ruff@0.3.0 check

Install/Update Tools to bin

https://docs.astral.sh/uv/guides/tools/#installing-tools

For frequently used tools, you can install them to the bin directory in PATH with uv tool install.

# Example of installing ruff
uv tool install ruff

# ruff is now available
ruff --version

# Tools installed this way don't become available as modules, so the following will fail
python -c "import ruff"

# Update ruff installed in bin to latest version
uv tool upgrade ruff

# Update ruff installed in bin to version 0.4 or higher
uv tool install ruff>=0.4

pip-Compatible CLI

https://docs.astral.sh/uv/getting-started/features/#the-pip-interface

Although rarely used, I'll mention that manual environment and package management is possible with pip-compatible CLI.
It's intended for use in legacy workflows that want to use uv with the pip interface, or cases that cannot be controlled with high-level commands.

Note:

Since it doesn't aim to completely mimic pip, you may encounter behavioral differences. ⁸

Simply add uv before traditional pip commands.

For example:

uv pip install
uv pip list
uv pip uninstall

Virtual environment (venv) creation is possible with:

uv venv

Summary

The development experience with uv is very good, so please try it!

Motivation and Methods for Migrating Existing Python Projects to uv

xrc — Sat, 14 Jun 2025 05:01:46 +0000

Article Overview

This article describes the motivation and methods for migrating existing Python projects to uv management.
The detailed usage of uv is not covered in this article (a separate article is planned).

Note: The content of this article is based on information from uv v0.6.13. Please refer to the official documentation for the latest information.

Target Audience

People who are interested in uv but hesitate to migrate
- → I recommend creating a branch and trying migration to experience the usability.

Common Existing Configuration of Python Projects

We assume the following common configuration for existing Python projects:

Management Target	Management Method
Python Version	pyenv
Dependencies	pip + requirements.txt
Virtual Environment	pyenv-virtualenv or venv

This is a common configuration when not using modern package managers.

Issues with the Above Configuration Management

When managing with the above configuration, you encounter the following issues.
I've also included the causes and possible countermeasures.

Issue	Cause	Countermeasures
Dependency resolution often fails during library installation, forcing manual investigation and resolution	pip's dependency resolution algorithm is relatively naive¹, making it impossible to build completely consistent dependencies overall	• Use tools with more advanced dependency resolution algorithms • Use tools with clear error messages
Complete environment reproduction is difficult because transitive dependencies cannot be managed (especially in machine learning, complete environment reproduction is desirable)	requirements.txt only manages directly dependent libraries²	• Use tools with lock file mechanisms • Containerize each application
When running locally, forgetting to activate the virtual environment and running pip install installs globally, easily contaminating the global environment	pyenv-virtualenv and venv virtual environments require manual activation	• Use tools that can use virtual environments without being conscious of it
Production dependencies and development dependencies tend to be mixed together, making it difficult to configure minimal environments, properly separate CI pipelines, and making them fragile/unclear	Everything tends to be put in a single requirements.txt	• Use tools that can manage them separately

Brief Explanation of uv

Using uv, a Python development environment management tool, can solve the above issues.

https://docs.astral.sh/uv/
You can understand the overview of uv by looking at the Introduction page above.

However, let me briefly list the features here:

Can manage Python versions, dependencies, and virtual environments with uv alone
Has an intuitive CLI (similar to poetry)
Operates extremely fast (uv is written in Rust and solves dependency resolution problems quickly)
Has cross-platform lock files
Has advanced dependency resolution algorithms
Supports macOS, Linux, Windows

For Rust users, it's a "Cargo in Python" philosophy tool, so the user experience is close to Cargo and very user-friendly.

I compared it with Poetry and PDM, but I think uv is the way to go now as the latest tool.
uv has the advantage of being able to manage Python versions, making other tools unnecessary, and operating surprisingly fast compared to them.
Although uv is in version 0.x, it is already considered Stable and core functions are already stable, so I think it's ready for production use.
In the latest Technology Radar (April 2025, Vol32), it received the highest rank of Adopt (strongly recommended for adoption if it fits the project).

Preparation: Installing uv

https://docs.astral.sh/uv/getting-started/installation/

Please install the standalone version from the above (installing with pip install ties it to the Python environment, so if you can install the standalone version, that's better).

$ curl -LsSf https://astral.sh/uv/install.sh | sh
downloading uv 0.6.13 x86_64-unknown-linux-gnu
no checksums to verify
installing to /home/ec2-user/.local/bin
  uv
  uvx
everything's installed!

Migration Steps for Existing Projects to uv Management

We assume migrating a repository called my-python-repo managed with the above configuration to uv management.

https://docs.astral.sh/uv/guides/projects/

1. `uv init` & Setting Python Version

By running the following in the project root, we initialize it as a uv-managed project using Python 3.13.2.

$ uv init -p 3.13.2
Initialized project `my-python-repo`

This will create main.py, pyproject.toml, .python-version, and README.md.

main.py

def main():
    print("Hello from my-python-repo!")

if __name__ == "__main__":
    main()

pyproject.toml

[project]
name = "my-python-repo"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.13.2"
dependencies = []

.python-version

3.13.2

When you run uv run main.py, a virtual environment (.venv directory³) and uv.lock are created.

$ uv run main.py
Using CPython 3.13.2
Creating virtual environment at: .venv
Hello from my-python-repo!

main.py is not needed, so you can delete it.
Also, you should update the meta information such as the project name in pyproject.toml as needed.

2. Adding Dependencies to `pyproject.toml`

https://docs.astral.sh/uv/guides/projects/#managing-dependencies

Since uv manages dependencies in pyproject.toml, we migrate the current requirements.txt content there.

Migration from requirements.txt can be done with uv add -r, but first, if requirements.txt contains both production-required libraries and development-only libraries, separate them into two.

Example:

requirements-new-lib.txt

pyarrow==19.0.1
pandas==2.2.3
lightgbm==4.6.0
...

requirements-new-dev.txt

moto==5.1.3
my-python-test-libs==1.4.2
...

Using the above, add dependencies to pyproject.toml with the following commands:

$ uv add -r requirements-new-lib.txt
$ uv add -r requirements-new-dev.txt --dev

If there are conflicting dependencies that cannot be resolved, you will get an error like the following.
For example, if there is a repository called my-python-test-libs (fictitious) like in the above example,
and it requires pandas < 2.0.0, it will conflict with pandas==2.2.3.
If my-python-test-libs is under your management, it's desirable to test that pandas 2.2.3 can be used without problems and update the dependency.

  Updated ssh://git@xxx.org/my-techorg/my-python-test-libs.git (6gp94f50b4dc39402f612f9df7bdd6aabbc53471)
  × No solution found when resolving dependencies:
  ╰─▶ Because your project depends on pandas==2.2.3 and my-python-test-libs==1.4.2 depends on pandas>=1.3.0,<2.0.0, we can
      conclude that your project and my-python-test-libs==1.4.2 are incompatible.
      And because only my-python-test-libs==1.4.2 is available and my-python-repo:dev depends on my-python-test-libs, we can conclude that
      your project and my-python-repo:dev are incompatible.
      And because your project requires your project and my-python-repo:dev, we can conclude that your project's
      requirements are unsatisfiable.
  help: If you want to add the package regardless of the failed resolution, provide the `--frozen` flag to skip locking
        and syncing.

However, using --frozen allows you to force addition without recording to the lock file⁴.
If you really want to add it as is, you should understand that runtime errors may occur due to how my-python-test-libs uses pandas.

3. Testing

Confirm that it works correctly after uv migration by running the application or executing automated tests.
For example, to run a uv-managed Python application, execute uv run as follows:

$ uv run my-python-repo-main.py

4. Clean Up Unnecessary Items

Delete unnecessary requirements.txt
If there are shell scripts executing Python scripts, rewrite them to go through uv and other cleanup tasks to complete the migration.

Summary

The migration is just this much, and I think it can be done easily without any particular difficulty.
The development experience with uv is very good, so I recommend it.

References

https://docs.astral.sh/uv/

pip seems to be getting stronger ↩
You can create a lock file with pip freeze > requirements.lock, but you probably don't do that... ↩
uv also uses .venv as a virtual environment (but it's designed to be usable without being conscious of it) ↩
https://docs.astral.sh/uv/reference/cli/#uv-add ↩

Introducing Code Review Best Practices Repository

xrc — Thu, 06 Mar 2025 16:57:27 +0000

I'd like to share a repository I've put together that compiles various code review best practices. This collection brings together insights from my personal experience, along with valuable knowledge gathered from books and technical articles.

https://github.com/teihenn/effective-code-review

What's Inside

The repository covers several aspects of the code review process:

Benefits of code reviews - Why they matter for team productivity and code quality
Practical coding tips - Writing code that's easier to review
PR preparation guidelines - How to structure your changes for efficient reviews
Reviewer best practices - Approaches for providing constructive feedback
Reviewee best practices - How to receive and implement feedback effectively

Why I Created This Repos

As code reviews became an increasingly significant part of my workflow, I wanted to organize the knowledge I've gathered to make the process more efficient and valuable for everyone involved. While many of these practices come from established sources and experienced developers, I've curated them based on what I've found most helpful.

Available in Multiple Languages

The content is available in both Japanese and English to make it accessible to a wider audience.

Exploring the Repository

If you're looking to improve your code review process or just curious about best practices, feel free to explore the repository. I welcome any feedback or additional insights you might have!

https://github.com/teihenn/effective-code-review

Note: This is a curated collection of practices from various sources, including published books and articles, combined with personal observations. Full references are included in the repository.

Edit .json.gz Files Effortlessly with jgze – A Flexible CLI Tool

xrc — Sun, 17 Nov 2024 12:20:26 +0000

Working with .json.gz files can be tedious, especially when you need to extract, edit, and recompress them manually. Meet jgze, a command-line tool that simplifies this process by allowing you to directly edit .json.gz files in a seamless workflow.

https://github.com/teihenn/jgze

What is jgze?

jgze is a CLI tool designed to let you edit .json.gz files without the hassle of separate decompression and recompression steps. It also provides flexibility in handling file formats during the editing process.

Key Features

Direct Editing: Open and edit .json.gz files as if they were plain JSON files.
Pretty Formatting During Editing: Regardless of the original file's format (compact or JSON Lines), the tool presents the content in a pretty-printed, readable structure during editing.
Automatic Reformatting: After editing, jgze saves the file back to its original format (e.g., compact, pretty-printed, or JSON Lines).

Usage

Run jgze to open your .json.gz file in your preferred editor.(default: vim)
Edit the content in a pretty-printed format for easier readability.
Save and close – the file will automatically be compressed and reformatted to its original structure.

# Example usage
jgze your_file.json.gz

Example: Compact to Pretty and Back to Compact

Original (Compact Format):

{"key1":"value1","key2":"value2","key3": "value3"}

Editing (Pretty Format):

{
  "key1": "value1",
  "key2": "value2",
  "key3": "value3"
}

Suppose you edited this as follows:

{
  "key1": "value1",
  "key2": "value2"
}

Saved File (Reverted to Compact):

{"key1":"value1","key2":"value2"}

Why Use jgze?

Traditional workflows with .json.gz files require decompression, manual editing, and recompression – a repetitive and error-prone process. With jgze, you can:

Save time by skipping manual steps.
Easily read and edit JSON content in pretty-printed format.
Preserve the file’s original format, ensuring compatibility with downstream systems.

Installation

You can install jgze via Cargo or download the pre-built binaries from the GitHub releases page.

# Install via Cargo
cargo install jgze

Alternatively, download the appropriate binary for your platform from the GitHub repository.

Example Use Case

Imagine you're working with large .json.gz files. Instead of juggling multiple tools, use jgze to directly edit and maintain the file format.

Get Started

jgze is open-source and available on GitHub. Feel free to explore the repository.

DEV Community: xrc

Easily Set Up Your Usual tmux Pane Layout

Overview

tsps Demo

Key Features

Installation

Basic Usage

Simple Pane Splitting

Using YAML Configuration Files

YAML Configuration Files

Simple Example

More Practical Example

Configuration Options Details

Conclusion

Using uv Environment Kernels in Jupyter Notebook

Article Overview

Assumed Scenario

Kernel Addition Steps

1. Clone my-python-repo

2. Create Virtual Environment from uv.lock

3. Add ipykernel to Virtual Environment for Jupyter Kernel Recognition

4. Register Virtual Environment as Jupyter Kernel

5. Open Jupyter Notebook and Use the Kernel

Kernel Removal Steps

How to Add Libraries in Kernels Linked to uv Virtual Environment

Summary

References

Essential uv Usage for Daily Development

Article Overview

Main Things Managed by uv

About Python Version Management

About Lock Files

Virtual Environment

Comparison of Flow from Clone to Application Execution (Without uv / With uv)

Usage

Initialize Project with uv

Python Management

Check Available/Installed Python Versions

Install Python

Permanently Change Python Version Used by uv Command

Dependency Management

Add/Update Dependencies

Remove Dependencies

Python Execution

Sync Virtual Environment State with uv.lock

Tool-Related

Run Tools Without Installing

Install/Update Tools to bin

pip-Compatible CLI

Summary

Motivation and Methods for Migrating Existing Python Projects to uv

Article Overview

Target Audience

Common Existing Configuration of Python Projects

Issues with the Above Configuration Management

Brief Explanation of uv

Preparation: Installing uv

Migration Steps for Existing Projects to uv Management

1. uv init & Setting Python Version

2. Adding Dependencies to pyproject.toml

3. Testing

4. Clean Up Unnecessary Items

Summary

References

Introducing Code Review Best Practices Repository

What's Inside

Why I Created This Repos

Available in Multiple Languages

Exploring the Repository

Edit .json.gz Files Effortlessly with jgze – A Flexible CLI Tool

What is jgze?

Key Features

Usage

Example: Compact to Pretty and Back to Compact

Why Use jgze?

Installation

Example Use Case

Get Started

Permanently Change Python Version Used by `uv` Command

Sync Virtual Environment State with `uv.lock`

1. `uv init` & Setting Python Version

2. Adding Dependencies to `pyproject.toml`