Bruno Alla - TILs

Configuring automatic generation of GitHub releases

Mon, 02 Feb 2026 00:00:00 GMT

On a few projects, I've been using the GitHub automatic release notes generations for while to get a list of all the changes that have been merged since the last release:

I believe it's generated from the title of all the PRs which have been merged since the last release, and I usually need to edit it manually to omit internal changes which don't impact the code installed by the users, like dependabot updates.

I only discovered today that this is configurable to exclude some authors or labels automatically. This is achieved via the .github/release.yml.

I stumbled upon this feature after seeing the config file edited in the pyproject-fmt project.

Using uv.lock file in tox

Fri, 05 Dec 2025 00:00:00 GMT

I've migrated all my open source packages to uv a while back, and the ones which are Django packages are using tox to run the tests against all supported combination of Django + Python versions.

However, I didn't realise that the tox-uv plugin does not install dependencies from the uv lockfile by default.

The realisation came in the django-money project: the test were running fine despite the lockfile being out of date.

This is explicitly documented on the tox plugin project, but I completely missed that, and assumed it would just magically work.

The fix I suggested is heavily inspired by Adam Johnson's setup (example from django-cors-headers). When I don't know how to do something in Django 3rd party packages, I often check one of his packages and always learn something from it.

Here are the key points:

Add runner = uv-venv-lock-runner to the tox test envs
Move the Django versions from tox.ini to pyproject.toml in dependency-groups and replace them by dependency groups
Add tool.uv.conflicts to mark the dependency groups as incompatible for uv (documentation)

That's it! Once again, thanks Adam!

Detecting a repeated sequence in a string

Wed, 03 Dec 2025 00:00:00 GMT

A challenge that came up during Advent of Code 2025 day 2, where one had to detect whether a string was made up of a repeated sequence: ABCABCABC.

I initially wrote the algorithm by hand, but wasn't pleased with the performance nor by how elegant the solution was. After having solved it, I wanted to learn more and found this page listing a few option. This solution caught my attention:

bool(re.fullmatch(r"(.+)\1+", value))

I'm more used to using the re.match function, but in this case we need the re.fullmatch:

If the whole string matches the regular expression pattern, return a corresponding Match. Return None if the string does not match the pattern; note that this is different from a zero-length match.

I never really needed that, but it's good to have found a use case for it. Hopefully, I will remember this trick next time I need it!

HTML meta tag: fediverse:creator

Sat, 22 Feb 2025 00:00:00 GMT

I came across a really nice tool to check your site meta tags, icon, colors and RSS feeds. It's lens.rknight.me and found most of the infos when ran it against this site. However, it taught me about the fediverse:creator meta tag which I didn't know about.

I sadly don't remember how I heard about it, but this post will be how I remember it, and who knows maybe how someone else discovers it.

Docker ADD vs COPY instructions

Mon, 02 Dec 2024 00:00:00 GMT

While reviewing a change in Cookiecutter Django, a co-maintainer (Fábio C. Barrionuevo da Luz @luzfcb) pointed at a section of the Docker documentation outlining the subtle, but important, differences between ADD and COPY.

If you asked me yesterday, I wouldn't have been able to tell you the difference, and this was indeed enlightening. My takeaways:

Start with COPY to copy files into the container, being from the host filesystem or from another stage.
If the file is only needed temporarily, use a RUN instruction with bind mount instead.
Use ADD if you need to put files into your container from a remote source.

I don't expect to remember this in one month time, but hopefully this page will help me find the resource quickly next time I need it.

Add button to share on Mastodon to my posts

Fri, 29 Nov 2024 00:00:00 GMT

Similar to my earlier TIL about adding "share on Bluesky" to my blog, I just added support for sharing my posts on Mastodon from the bottom of my posts and TILs.

As far as I know, there is no official way to it, because there is no central place to direct people to, unlike BlueSky or Twitter/X. However, today I stumbled upon a neat solution on the DjangoTV website and I liked it as a user so decided to implement it here.

It works using a tool by @kytta deployed at toot.kytta.dev. I initially tried to use my BlueSky snippet, but that prefilled the input with + instead of spaces, because I used new URLSearchParams(...).toString(), which was unnecessary in this case. Then I passed the text with hashtags, and noticed that the hashtags were lost. It makes sense as the # has a special meaning in the URL. I replaced these with the URL encoded version manually and it worked.

Here is the final snippet:

function getMastodonSharingUrl(title, tags, postUrl, handle) {
  const hashtagsStr = tags
    ? tags.map((ht) => `%23${ht.replace(" ", "")}`).join(" ")
    : "";
  const textParam = `${title} by ${handle} ${postUrl} ${hashtagsStr}`;
  return `https://toot.kytta.dev/?text=${textParam}`;
}

Again, the whole implementation, if you're curious.

Javascript console.log() object string substitution

Wed, 27 Nov 2024 00:00:00 GMT

A common issue with Javascript's console.log is that if you log a template string that contains a complex JS object, you'll get a useless output:

>> const obj = { test: 1 }
>> console.log(`obj=${obj}`)
obj=[object Object]
>> console.log('obj=%s', obj)
obj=[object Object]

I was trying to debug something and copilot suggested to use %j formatting which seemed promising:

>> console.log('obj=%j', obj)
obj=%j
Object { test: 1 }

Unfortunately that was an hallucination, the %j isn't doing anything, and is still present in the printed string.

That got me curious, so I looked it up online and found the dedicated MDN page with the %o substitution:

>> console.log('obj=%o', obj)
obj=Object { test: 1 }

James Bennet's DjangoVer suggestion

Mon, 25 Nov 2024 00:00:00 GMT

I saw this post from James Bennet shared around in a few places last week, and only came around to read it now. The TL;DR is that it's making the case for "DjangoVer", a versioning scheme to align 3rd party Django packages versions with the latest version of Django version they support.

I think it's a great idea, it would make it much easier to see at a glance in your requirements.txt/pyproject.toml if you're ready to upgrade, or at least give you an idea on likely you're ready to upgrade:

If most packages are a couple of major versions behind, you can assume you're not ready.
If most package are aligned except a couple with one minor behind, it's probably worth a try.
If a single package is dragging behind, time to find an alternative.

I'll think about it for a while, but I'll probably move my projects to this scheme at some point.

New argument to Django redirects

Sun, 24 Nov 2024 00:00:00 GMT

A pull request has been merged into Django this week, to make it easier to do a redirect while preserving the HTTP method.

It took me an embarrassingly long time in my career to learn that the most common redirects (301 and 302) don't preserve the HTTP method. I also often confuse the known temporary permanent, and it's even harder to remember which one is which between 307 and 308.

With this new change, it will make these status code easier to learn, remember and use them. This higher level API is a much welcome addition in my opinion, replacing this:

def my_old_vew(request):
    return HttpResponseRedirect(status_code=307)

By:

def my_old_vew(request):
    return HttpResponseRedirect(preserve_method=True)

Improve Django development experience with django-fastdev

Fri, 22 Nov 2024 00:00:00 GMT

I came across a post from Trey Hunner which resonated with me, about how Django sometimes swallows errors in its templates. It can be convenient on prod, when the code is proven to be correct, but when I develop I'd rather have louder errors to guard against typos. adamghill replied with the 3rd party package django-fastdev. I've never heard of before but it seems very useful.

I've inspected the code to understand a bit how it works, and it's pretty much all implemented in the apps.py file. It's working by monkey patching various parts of Django. One may find this approach questionable but as long as it works, makes me more productive and that I don't have to maintain it, I'd be more than happy to use it. It's also very easy to remove if it ends up not working any more.

This is a creative and pragmatic way to solve the problem, bypassing entirely the much more difficult way to get thing into core. Underlines the points recently made by Carlton Gibson about the power of the 3rd party Django apps.

Adding "share on Bluesky" to my blog

Mon, 18 Nov 2024 00:00:00 GMT

I just added support for sharing my posts on Bluesky from the bottom of my posts and TIL.

The way it works is quite similar to Tweeter/X and since I already had this feature, it was pretty quick to adapt.

The main difference is that Tweeter has several parameters to provide your text, URL, hashtags and mentions separately, while the Bluesky method has a single field. Here is how it looks like:

function getBskySharingUrl(title, tags, postUrl, bskyUsername) {
  const hashtagsStr = tags
    ? tags.map((ht) => `#${ht.replace(" ", "")}`).join(" ")
    : "";
  const bskyParams = new URLSearchParams({
    text: `${title} by @${bskyUsername} ${postUrl} ${hashtagsStr}`,
  }).toString();
  return `https://bsky.app/intent/compose?${bskyParams}`;
}

You can see the whole implementation here.

I pass my own username as bskyUsername and that doesn't seem to pull through, it's showing as text instead of being recognised as my handle. Let me know if you know how to fix that.

Trigger further workflows on pushes from GitHub actions

Wed, 02 Oct 2024 00:00:00 GMT

GitHub actions aren't trigger by actions from other workflows by default. If you have a workflow that pushes back changes after linting/formatting, you can get it trigger another round of CI by checking out with a GitHub token:

- uses: actions/checkout@v4
  with:
    token: ${{ secrets.GH_PAT }}
- name: Make some changes
  run: ...
- name: Push changes back
  uses: stefanzweifel/git-auto-commit-action@v5

Opening the PyCharm registry

Wed, 17 Jul 2024 00:00:00 GMT

Today, I encountered an issue with my IDE (PyCharm) and its integration with Docker. It wouldn't refresh my remote interpreter, which broke most of the intellisense and go to definition. I found this Youtrack issue which described my problem close enough.

Someone replied and suggested to change a python.use.targets.api setting, which is a bit hidden, as it's a registry entry. I searched how to open the registry, but couldn't find much resources.

The answer is:

<kbd>⌘</kbd> + <kbd>⌥</kbd> + <kbd>⇧</kbd> + <kbd>/</kbd> to open the maintenance context menu
Choose the first option, "Registry..." from it

Done! Hopefully that'll help me and others in the future.

Python print function keyword arguments

Wed, 08 May 2024 00:00:00 GMT

The Python print function is one of the first one folks learn about, since it's part of the "Hello World" program. It's often presented with its most basic usage, by passing a single argument to it:

print("Hello World")

Simple, and readable.

However, I recently rediscovered its keyword arguments, especially the end one, that defaults to \n (newline character), which is added at the end of whatever you want to print. That's why when you call the above snippet multiple times, you'll see each string printed on a new line, as opposed to have them on the same.

The problem

When running a long command, if you want to print the progress of the command, you might be tempted to do:

def do_thing_over_many_entries(entries):
    total = len(entries)
    print(f"Starting processing {total} entries")
    for index, entry in enumerate(entries, 1):
        print(f"Processing entry {index}/{total}")
        # Do the thing
    print("All done")

This will print a wall of text, e.g.

Starting processing 4000 entries
Processing entry 1/4000
Processing entry 2/4000
Processing entry 3/4000
...
Processing entry 4000/4000
All done

Which might be a bit disruptive as it'll fill up your terminal.

Solution wih standard library

Using the end keyword argument is useful, you can pass carriage return \r to instead update the same line in place:

def do_thing_over_many_entries(entries):
    total = len(entries)
    print(f"Starting processing {total} entries")
    for index, entry in enumerate(entries, 1):
        print(f"Processing entry {index}/{total}", end="\r")
        # Do the thing
    print("All done")

Which will update the "Processing entry..." line as it goes:

Starting processing 4000 entries
Processing entry 4000/4000
All done

Solutions with 3rd party packages

This is a simple example with vanilla Python, but other libraries are providing higher abstractions for this kind of operation:

Rich
TQDM

If you can afford to add a dependency to your project, check these out.

Crossed app logo in macOS notifications

Wed, 13 Mar 2024 00:00:00 GMT

Occasionally, on macOS, I get some notifications with the app logo is crossed out, like this:

<br />

I thought it was because of permissions issues, but couldn't find the problem in my settings. Turns out, the fix is to kill the Notification Center, and let it starts again automatically. This can be done via the Activity Monitor, or via the command line:

killall NotificationCenter

I found the solution on Reddit, but since I'll inevitably have forgotten next time it happens, making note of it here.

Running Python from subprocess cross platforms

Sat, 04 Nov 2023 00:00:00 GMT

In one of my Python package offering a CLI, I added the ability to run it as python -m mypackage. Natuarally, I wanted to write a small test to make sure it worked, which used the subprocess module to run python with the -m flag. Simple enough, right?

result = subprocess.run(["python", "-m", ...], ...)

Well, when I pushed to CI, I realised that the python executable couldn't be found on Windows... It's probably called python.exe or somthing like that. Do I need to introduce a condition in my test depending on the platform? Surely, there must be a better way.

After a quick search, I found about sys.executable, which does exactly that. Neat!

Here is how my test looks like now:

import subprocess
import sys


def test_can_run_as_python_module():
    result = subprocess.run(
        [
            sys.executable,
            "-m",
            "mypackage",
            "--help"
        ],
        check=True,
        capture_output=True,
    )
    assert result.returncode == 0
    assert b"my-package [OPTIONS]" in result.stdout

Hope that helps!

Integrating django-extensions shell plus with Pycharm console

Wed, 27 Sep 2023 00:00:00 GMT

The django-extensions is a package which I install in all my Django projects, it's a toolbox full of useful commands and utilities. One of the commands is shell_plus which is a replacement for the standard Django shell command, than provides a better DX, close the iPython, as well as automatically importing all the models as well as the most common utilities. As a Pycharm user, I often use the integrated console, which responds to the IDE shortcuts and provides other small DX improvements, similar to what shell_plus offers.

By default, Pycharm integrated console does not do the automatic imports from shell_plus, but it's quite easy to add them, hence getting the best of both worlds. Here are the steps:

Open the settings
Go to the Build, Execution, Deployment > Console > Django Console page

Add the following to the end of the Starting script field:

import sys; print('Python %s on %s' % (sys.version, sys.platform))
import django; print('Django %s' % django.get_version())
sys.path.extend([WORKING_DIR_AND_PYTHON_PATHS])
if 'setup' in dir(django): django.setup()
import django_manage_shell; django_manage_shell.run(PROJECT_ROOT)

from django_extensions.management import shells
from django.core.management.color import color_style
imported_items = shells.import_objects({}, color_style())
for k, v in imported_items.items(): globals()[k] = v

And that's it! Now when you open the Pycharm console, all your models and utilities will be available, using the shell_plus logic.

Debugging redirect cycle error in Django tests

Wed, 30 Aug 2023 00:00:00 GMT

I recently joined a new team with a medium-sized Django project, so naturally I tried to run django-upgrade on it. It modified a lot of URL routes and upgraded the syntax from re_path to path. However, when I ran the tests, I got some failures with the following message:

django.test.client.RedirectCycleError: Redirect loop detected.

I could see the URL being used in the test, but nothing obvious came to mind. The patterns that were changed looked fine, and the problem persisted if I reverted to the pattern in for that URL. I tried to set a breakpoint in the affected view, but it wasn't reached, where I was expecting it to. It quickly became clear that my test suddenly resolved to a different view, but which one? There are hundreds of routes in the project! I figured that the answer might be in the exception that Django raises in the test.

I wrapped my call to self.client.get(...) in my test into a try/except block and inspected the RedirectCycleError being raised:

class MyViewTest(TestCase):
    def test_page_not_accessible(self):
        url = reverse("my-view")
        try:
            response = self.client.get(url, follow=True)
        except RedirectCycleError as exc:
            breakpoint()

    assert response.status_code == 404

I ran the test again and inspected the exception from the debugger. the exception has a last_response attribute, which is a HttpResponseRedirectBase, which itself give the URL name that was used by accessing the resolver_match.url_name attribute. Putting it all together:

class MyViewTest(TestCase):
    def test_page_not_accessible(self):
        url = reverse("my-view")
        try:
            response = self.client.get(url, follow=True)
        except RedirectCycleError as exc:
            print(exc.last_response.resolver_match.url_name)

    assert response.status_code == 404

That gave me a URL name which was defined as follows:

from django.urls import re_path

from .views import product_redirect_view

app_name = "site"

urlpatterns = [
    re_path(r"^", product_redirect_view, name="product-redirect"),
]

It's higher in the list of routes, so higher priority, and is missing a trailing $ hence matching anything. I'm not sure how it worked before, to be honest, but that's another story I need to figure out next. For now, I'm happy that I found the cause of the problem with debugging.

Using Python's inspect module to load test data

Mon, 07 Aug 2023 00:00:00 GMT

The problem

In one of my Django project, a pattern started to emerge in my tests, where I needed mock data coming out a 3rd party API. The 3rd party API docs often shows an example, which is great to get a basic payload to use in tests. However, I couldn't paste it directly on my test code:

It is in JSON format, which isn't necessarily valid Python. For example if the example contains some null or boolean values (false in JSON vs False in Python).
It might be a few 100 lines long, distracting from the test code
May contain a lot of data irrelevant to the test.

Still, I like to have a snapshot of the example, in my code: some fields might be useful in the future, and having the full payload in git enables me see if some fields are being added or removed by the 3rd party.

Initial solution

My solution is to paste the example in a JSON file, and write a small utility function to load the json from the file. To separate it from my test, while leaving it close, I started to put it in a data directory directly adjacent to my test file:

tests/
├── data/
│   └── example.json
└── test_example.py

Then, I wrote a small utility function to load the data, in the test module:

import json
from pathlib import Path


def load_data(filename):
    fixture_path = Path(__file__).parent / "data" / filename
    return json.loads(fixture_path.read_text())

I used it once, and moved on. Then I needed something similar, but also wanted the ability to override some fields, so I wrote another one, adding a overrides parameter:

def load_data(filename, **overrides):
    fixture_path = Path(__file__).parent / "data" / filename
    base_data = json.loads(fixture_path.read_text())
    return {**base_data, **overrides}

After a while, as I added more integrations, a few versions popped up in my codebase. They were all similar, but because of the __file__ magic, I couldn't easily reuse my function: the fixture would be loaded from directory adjacent to my utility function, not from the test module. However, I knew that Python introspection would probably let me do what I wanted.

The reusable solution

A quick search brought up a Stack Overflow answer describing exactly what I needed, using the inspect module. Here is how my final solution looks like:

import inspect
import json
from pathlib import Path
from typing import Any


def load_json(
    fixture_name: str,
    **overrides: Any,
) -> dict[str, Any]:
    """
    Load JSON from a fixture located a `data` directory.

    The directory is adjacent to the caller.
    """
    caller_file = inspect.stack()[1].filename
    data_path = Path(caller_file).parent / "data"
    fixture_path = data_path / fixture_name
    loaded_data = json.loads(fixture_path.read_text())
    return {
        **loaded_data,
        **overrides,
    }

This solution has some limitations (the caller must be the Python module adjacent to the test data, doesn't work with a top level array, ...), but it works fine for my use case. I can now reuse it across my codebase and improve it as my need evolve.

Terraform and ECS task revisions

Fri, 05 May 2023 00:00:00 GMT

Today, I came across a problem with Terraform and ECS task revisions. The setup is that the ECS task definition and service are both defined in a Terraform, with a fixed revision tag of latest:

resource "aws_ecs_task_definition" "app_task" {
  family = "app-task"

  container_definitions = jsonencode([
    {
      name  = "myapp"
      image = "XXXX.dkr.ecr.us-east-1.amazonaws.com/myapp:latest"
      ...
    }
  ])
  ...
}

resource "aws_ecs_service" "app_service" {
  name            = "app-service"
  task_definition = aws_ecs_task_definition.app_task.arn
  ...
}

The application code lives elsewhere, and on the app's CI, we build the Docker image, tag it as latest, push to ECR and update the task definition using the AWS CLI by forcing a redeployment. The same image tag is running, but ECS adds a number at the end of the revision, so the task definition revision is something like app-task:1.

The problem is that Terraform doesn't know about these deployments. After a few releases, the task will look like app-task:12, and when running terraform plan without any changes in the infra code, I can see that Terraform is trying to roll back to the earlier version:

~ task_definition  = "arn:aws:ecs:us-east-1:XXXX:task-definition/app-task:12" -> "arn:aws:ecs:us-east-1:XXXX:task-definition/app-task:1"

I found a solution in this reddit post, where they describe the same issue, and the answer suggest a few solutions. I went with the first one, which works for now:

resource "aws_ecs_service" "app_service" {
  name            = "app-service"
  task_definition = aws_ecs_task_definition.app_task.arn
  force_new_deployment = true

  lifecycle {
    ignore_changes = [task_definition]
  }
}

Someone commented a drawback of using that solution, since it prevents actual Terraform changes to the task definition, but we might be able to live with that limitation by commenting out that bit when we need to do it.

Bulk resize images with sips

Thu, 04 May 2023 00:00:00 GMT

Today, I needed to bulk resize a bunch of images that I had in a folder. I decided to ask ChatGPT to solve my problem for me and it did it beautifully. Here is the prompt I used:

What's he quickest way to resize some JPEG images in a given folder on macOS? The original dimensions are 3984×3984 and want to get them around 1000×1000, with an average quality, while staying in JPEG format.

It suggested to use sips (Scriptable Image Processing System) and not only gave me the solution, but also the explanation of the command, and explained how to open the terminal app on macOS, which is great for people who are not familiar. Here is the command it suggested:

for img in *.jpg
  do sips -Z 1000 --setProperty format jpeg --setProperty formatOptions 65 "$img" --out "Resized/$img"
done

And here are the explanations:

This command does the following:

Loops through all JPEG files in the folder with the *.jpg file extension.

Resizes the images to fit within a 1000x1000 pixel bounding box, maintaining their aspect ratio (-Z 1000).

Sets the output format to JPEG and the quality to approximately 65% (average quality) using the --setProperty flags.

Saves the resized images in a new folder named "Resized" within the current folder (--out "Resized/$img").

After the command has completed, you should see a new folder named "Resized" in your original folder, containing all the resized JPEG images.

I initially got an error, because the Resized folder didn't exist, so I just created it. After that, it worked like a charm.

Translated database content with Django

Thu, 20 Apr 2023 00:00:00 GMT

Recently, while working on a Django project, I needed to have content in multiple languages. Django has a good support for translations, but that's only strings which are in the codebase. It's not uncommon to need models with content in the database that will be displayed to end user, getting into CMS territory, and these need to be translated. However, for my use case, I was just modeling a couple of fields, and it's an API backend, with an SPA frontend, so I didn't want to install something too complicated like Wagtail. I just needed a lightweight solution, that can work from the admin.

At a previous company, we wrote a custom implementation which relied on JSON field on the same model, and it worked well, but it wasn't fully integrated into the admin and we never open sourced it. So I was left with trying to find a similar implementation.

Rejected options

I looked at a few options, and rejected them for the following reasons:

django-parler: I've used it in the past, and it posed some issues. The main annoyance was that the translations were stored in a separate model, causing joins and extra queries. It also doesn't appear well maintained: at time of writing, the last release is 1,5 years old, and it's 2 Django versions behind in terms of support.
django-modeltranslation: a popular option, but creates one column per translated field per language, which is not optimal.

The solution

I ended up on django-modeltrans, which is using a single JSONField for all translations, is well integrated into the admin and supports modern versions of Django. Adding a model with translated fields is as simple as:

from django.db import models
from modeltrans.fields import TranslationField

class MyModel(models.Model):
    name = models.CharField(max_length=255)
    description = models.TextField()

    i18n = TranslationField(fields=("name", "description"))

    class Meta:
        verbose_name = "My model"
        verbose_name_plural = "My models"

This is pretty straightforward and very obvious that this model has translations and which are translated.

The admin integration can be customised with the built-in ActiveLanguageMixin, which limits shows the default language + the active language. In my case I had only 2 languages, so I copied that mixin in my codebase and tweaked it for my need. It's short (~10 lines, with comments), so that was relatively easy to do.

For simple cases, I highly recommend this package, it's simple and efficient. If your app is content heavy though, I'd recommend looking into a more fully fledged solution like Wagtail.

Python descriptors

Tue, 07 Feb 2023 00:00:00 GMT

I only learned today about a neat Python feature: descriptors. I came across that feature twice in the same day: once at work on a custom Django field for translations and a second time in this great article.

From the article, I dived a bit deeper and landed on the amazing "Descriptor How To Guide" from the Python documentation. The example of logging is a simple, yet practical one, that helped me "get" it:

class LoggedAgeAccess:
    """Descriptor class."""

    def __get__(self, obj, objtype=None):
        value = obj._age
        print(f'Accessing age={value}')
        return value

    def __set__(self, obj, value):
        print(f'Updating age to {value=}')
        obj._age = value


class Person:
    """Class using the descriptor."""

    # Descriptor instance
    age = LoggedAgeAccess()

    def __init__(self, name, age):
        self.name = name
        # Calls __set__()
        self.age = age

    def birthday(self):
        # Calls __get__() then __set__()
        self.age += 1

The guide expands on more advanced usages. I love how it starts simple, gets more complicated as you go, before expanding on the more formal definitions. A great resource from Raymond Hettinger.

Detecting unchanged pipx packages with Ansible

Fri, 18 Nov 2022 00:00:00 GMT

I recently moved provisioning of my MacBook to Ansible and one of the task that didn't work perfectly was installation of CLI packages using pipx: the playbook always detected the packages as changed, even if they were already installed.

I solved this by making use of the changed_when option, and checking whether the output of pipx install was saying that the package is already installed:

- name: Install pipx packages
  command: pipx install {{ item }} --python ~/.pyenv/versions/{{ pyenv_python_versions[0] }}/bin/python
  register: pipx_install_result
  changed_when: >
    pipx_install_result.rc == 0 and
    "'" + item + "' already seems to be installed." not in pipx_install_result.stdout
  loop: "{{ pipx_packages }}"
  tags:
    - pipx

Now my packages appear as "ok" instead of "changed" when running the playbook.

Victory 🎉

Provisioning my MacBook with Ansible

Thu, 17 Nov 2022 00:00:00 GMT

I wrote before how I scripted the setup of my Apple MacBook pro. At the time, I used a combination of bash scripts, Brewfile and Mackup. This was better than nothing, but it was not really runnable over and over.

In the meantime, Adam Johnson blogged about his setup, using Ansible, and I was curious about it. I never used Ansible by was interested to play with it, and it seemed like a good use case. I tried to adapt it for my need, but I quickly realised that I wasn't ready to actually run it on my machine (and therefore test it): I didn't want to mess anything.

Recently, my Mac had a hardware issue, and it came back from repairs wiped, so I decided to give it another go. I forked Adam's repo and started by removing everything I didn't understand/needed. I ended up keeping mostly the brew packages, casks and the pyenv versions. And with a fresh machine, I was able to test it out.

Once my machine was setup, I was able to add more tasks to install some packages with pipx, and by running the playbook again, Ansible added what was missing. I'm still using Mackup to back up & restore my preferences, but I'm considering moving that to Ansible as well.

Sudo with TouchID on macOS

Wed, 31 Aug 2022 00:00:00 GMT

A nifty trick learned from this blog post. This is mostly writing here for my own future reference:

Edit /etc/pam.d/sudo
Add the line auth sufficient pam_tid.so below the pam_smartcard.so line

Done!

Using Codespell to check for typos

Sat, 07 May 2022 00:00:00 GMT

Today, I stumbled upon Codespell, a tool to check for spelling mistakes in your code. I found out about it by looking at the PyScript repo, which they define in their pre-commit config. Since most of my repos are set up with pre-commit.ci already, I went ahead and added the config, which just a couple of lines:

repos:
  - repo: https://github.com/codespell-project/codespell
    rev: v2.1.0
    hooks:
      - id: codespell

It didn't raise a lot of issues, but it did catch a couple of typos here and there.

Using a temporary directory for media files while running tests in Django

Thu, 05 May 2022 00:00:00 GMT

Our Django test suite uses factory-boy to simplify generating mocked data for our tests. Some of our models are creating images, and by default they are all called 'example.jpg', and some suffix is added avoid collision. As a result the media folder was being filled with example_<radom suffix>.jpg.

Not only this filled the disk on our development machines, but it also may cause some flakiness in our tests if the filename is part of the assertion.

To avoid that, I configured our test settings to use a temporary directory as media root:

MEDIA_ROOT = tempfile.TemporaryDirectory().name

Since we use pytest-xdist to run test in parallel on the same machine, I've also included the worker name in the suffix:

PYTEST_XDIST_WORKER = env(
    'PYTEST_XDIST_WORKER',
    default='gw0',
)
MEDIA_ROOT = tempfile.TemporaryDirectory(
    suffix=f'_{PYTEST_XDIST_WORKER}',
).name

Once the session is complete, the temporary file is deleted, along with its content.

Tracking down a bug with tox and git

Tue, 03 May 2022 00:00:00 GMT

Today I wanted to track down what broke the CI of an open source library (django-coverage-plugin) which is testing against Django main branch.

The build was passing recently, but broke a few days ago. I needed to run something like a git bisect, except it was not on the project itself (which hadn't changed much) but on Django, while running the project's test suite.

The project is tested with tox, which I used to run an isolated environment to install a version of Django from an archive based on a git commit, which GitHub exposes:

[testenv]
deps =
    djangorev: https://github.com/django/django/archive/dcebc5d.tar.gz

I looked at the recent commits from the main branch, picked one from a few days ago, made sure it worked, and saved it as djangook env. I then selected the most recent one, made sure that it failed, and saved it as djangoko env.

I chose the middle revision and replaced djangook or djangoko, depending on the result, which led me to find the commit which broke the test for the coverage plugin.

This is more or less the steps that happens when doing a git bisect -or a dichotomy in mathematics- except here I couldn't use this tool, so I had to do it manually. Tox saved me ton of time as I was able to create several isolated environments quickly.

Adding TILs to my site

Sun, 01 May 2022 00:00:00 GMT

Inspired by Simon Willison, and driven by the will to write more on this site, I've decided to add a TILs section, where the format is shorter and requires less introduction than a fully fledge blog post.