Go to file
Jeff Moe 490249484c AGPLv3 license footer, ala hatch 2023-10-07 11:12:19 -06:00
config/hatch Docs with new hatch 2023-10-04 15:28:06 -06:00
src/tasteful_python Docs with new hatch 2023-10-04 15:28:06 -06:00
tests Re-create new project with hatch 2023-10-04 15:26:14 -06:00
.gitignore Ignore pycache 2023-10-04 15:40:45 -06:00
LICENSE.txt Re-create new project with hatch 2023-10-04 15:26:14 -06:00
README.md AGPLv3 license footer, ala hatch 2023-10-07 11:12:19 -06:00
pyproject.toml Re-create new project with hatch 2023-10-04 15:26:14 -06:00


Tasteful Python

Python suited to my taste.

Configuration files, code snippets, etc.


Install thusly.

Using Debian Bookworm (stable/12) as a base.


Dependencies that may be needed:

sudo apt install \
    --no-install-recommends \
    git git-lfs python3-pip python3-virtualenv \
    build-essential libssl-dev zlib1g-dev \
    libbz2-dev libreadline-dev libsqlite3-dev curl liblzma-dev \
    libncursesw5-dev xz-utils tk-dev libxml2-dev libxmlsec1-dev libffi-dev \
    ccache pipx


Get code and set up Python, suit to taste, such as:

git clone https://spacecruft.org/deepcrayon/tasteful-python
cd tasteful-python
virtualenv -p python3 env
source env/bin/activate
pip install --upgrade pip
pip install -r requirements.txt


  • Use ccache for caching builds.
  • Use apt for caching Debian packages.
  • Use PyPI cache for Python pacakges.

ccache Server

Set up Redis for ccache server.

apt install redis-server

ccache Client

Set up thusly.

Add to end of ~/.bashrc and source it or logout/login:


ccache client config file, change IP to Redis server.

mkdir -p ~/.config/ccache
cat > ~/.config/ccache/ccache.conf <<EOF
remote_storage = redis://
remote_only = true
reshare = true

devpi PyPI Cache Server

Set up a devpi PyPI (pip) caching server thusly:

mkdir -p ~/devel/devpi
cd ~/devel/devpi
virtualenv env
source env/bin/activate
pip install -U setuptools wheel pip
pip install devpi-server devpi-web

sudo mkdir -p /srv/devpi
sudo chown jebba:jebba /srv/devpi

devpi-init \
    --serverdir /srv/devpi

devpi-gen-config \
    --host= \
    --port 4040 \
    --serverdir /srv/devpi \

# meh supervisor, I guess
sudo apt install supervisor
sudo cp ~jebba/devel/devpi/gen-config/supervisor-devpi.conf /etc/supervisor/conf.d/

crontab -e
@reboot /usr/local/sbin/supervisord -c /home/jebba/etc/supervisor-devpi.conf

supervisord -c gen-config/supervisord.conf
sudo reboot

cd ~/devel/devpi
source env/bin/activate
devpi use
devpi login root --password ''
devpi user -m root password=FOO
devpi user -l
devpi logoff
devpi user -c jebba password=BAR email=foo@bar
devpi login jebba --password=BAR
devpi index -c dev bases=root/pypi
devpi use jebba/dev
devpi install pytest

Open up firewall port 4040/tcp.

devpi PyPI Cache Client

Set up the PyPI clients thusly substituting in the proper server IP:

mkdir -p ~/.config/pip
cat > ~/.config/pip/pip.conf <<EOF
trusted-host =
index-url =

index =


If different, typically older, versions of Python are needed, pyenv works well for this.

Set it up on a system thusly:

mkdir -p ~/devel/pyenv
curl https://pyenv.run | bash

If you want it to work every time the user logs in, add this to ~/.bashrc.

# pyenv
export PYENV_ROOT="$HOME/.pyenv"
command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init -)"
eval "$(pyenv virtualenv-init -)"

If you only want pyenv sometimes, copy the above lines to a file (e.g. ~/bin/deepcrayon-pyenv), the source the lines instead of running the file, ala source ~/bin/deepcrayon-pyenv.

To see versions of Python that can be installed:

pyenv install --list | sort -V
# Also:
pyenv latest --known 3
pyenv latest --known 3.11
pyenv latest --known 3.7

Perhaps install a bunch of versions, such as:

pyenv install 3.12
pyenv install 3.11.6
# or
pyenv install `pyenv latest --known 3.11`

pyenv install 3.10
pyenv install 3.9
pyenv install 3.8
pyenv install 3.7
pyenv install 3.6
pyenv install 3.5
pyenv install 3.13-dev

Use pyenv to set a particular version in a virtualenv:

mkdir -p foodir
cd foodir/
pyenv local 3.12.0
virtualenv -p 3.12.0 env
source env/bin/activate
python --version
pip install --upgrade pip setuptools wheel
pip install fooapp


Development setup.


Python Dependencies via pip

Install the Python requirements:

pip install -r requirements-dev.txt

Then run black on the Python files for nice formatting. Use --preview to get the next release style changes. Such as:

black --preview tasteful-python*

Python Dependenices via pipx:

Use pipx to install hatch dependencies so the hatch dependency versions don't conflict with the project's dependencies. Perhaps this should be done for all the development dependencies like black, flake8 (?).

Don't run this as root or in a virtual environment, just as regular user:

deactivate # if needed
pipx install hatch
pipx ensurepath
# perhaps logout / login or new terminal
eval "$(register-python-argcomplete pipx)"
# perhaps
_HATCH_COMPLETE=bash_source hatch > ~/.hatch-complete.bash
. ~/.hatch-complete.bash
echo ". ~/.hatch-complete.bash" >> ~/.bashrc







Build with hatch. Appears to be latest/greatest in Python ecosystem.

Hatch can also create new projects, set up directory structures, etc. Best approach may be to create good hatch setup, then copy over other example files as default file template for new projects.

For sample hatch config, see config/hatch/config.toml. The TOML file format is documented here:

Hatch Create

Create new project. Adding --cli imports click command line processing.

hatch new foo
hatch new --cli bar

For a pre-existing project, it can be set up for hatch thusly:

cd foo/
hatch new --init
hatch new --init --cli

Using --init on a pre-existing project won't create the directory structure, it just changes pyproject.toml.

Hatch Shell

After new hatch creation, enter the shell:

cd foo/
hatch shell

Hatch Version

Various hatch versioning commands:

# print version 0.0.1
hatch version
# increment major version 1.0.0
hatch version major
# increment minor version 1.1.0
hatch version minor
# increment patch version 1.1.1
hatch version patch
# increment rc version 1.1.1rc0
hatch version rc

Hatch Configuration

Default config file:

hatch config find

File gets put in ~/.config/hatch/config.toml.

Hatch Add Dependency

hatch run pip list
${EDITOR} pyproject.toml

Add dependency to dependencies section.

Then to Sync dependencies, re-run:

hatch run pip list

See also:

hatch dep show table
hatch dep show requirements

Hatch Testing

hatch run test
hatch run cov

Hatch Build

Build such as:

hatch build
hatch build --clean

Hatch Publish

Upload to PyPI:

hatch publish

Hatch Misc

hatch run which python3
hatch env
hatch config
hatch project metadata
hatch status


No Ruff

Not using ruff because:

  • The newer ruff linter from PyPI fails to run on ppc64le (page size memory error with Debian's kernel).
  • To rebuild ruff a rustc compiler needs to be installed.
  • To rebuild ruff the compiler version in Debian stable is too old, so it fails to build from source.

No Conda, No Anaconda

While the Conda and Anaconda software is free software, usage isn't free for companies, who must pay for access to the servers. So the code is libre, but actually using it the way it is commonly used, can't be done under libre terms. Using pip is fine, and anaconda isn't ever needed.


Alpha, under development.


Such as:

  • Find best-of-class ways to set up Python projects and code.
  • Starting code templates, headers for projects.
  • Proper directory layout, versioning, etc.
  • QT, argparse, daemon, web app, JACK, etc. templates.
  • Documentation system, perhaps Sphinx or something else SOTA.
  • Build system, probably hatch.
  • Push to PyPI test server.
  • Also re-build on ppc64le.
  • Linter, such as flake8 and bugbear.
  • mypyc.
  • Is pyenv best way to use arbitrary versions of Python?



Python Software Foundation


I am not a programmer, I'm learning Python.


Unofficial project, not related to the Python Software Foundation.

Upstream sources under their respective copyrights.


Copyright © 2023, Jeff Moe.

tasteful-python is distributed under the terms of the AGPL-3.0-or-later license.