I recently migrated several models to use a table-prefixed ULID data type (similar to Stripe IDs), for example, an ID like tbl_01JCSG38GGZZEC764V1CMXNRT9. I implemented this by creating a custom model field and applying it to my models. Everything functions correctly except for one anomaly: in the admin panel URL, an ID that should be vid_01JCSG38GGZZEC764V1CMXNRT9 is being transformed into vid_5F01JCSG38GGZZEC764V1CMXNRT9.

What’s even more puzzling is that the change page itself displays the correct ID (vid_01JCSG38GGZZEC764V1CMXNRT9), and both URL versions (with and without the extra 5F) work fine. This issue consistently occurs across all models using this custom field. I suspect there’s a bug in my custom field implementation, but I can’t locate it in my codebase or even within Django’s code. I’ve added breakpoints where the string is returned from the custom field, and there’s no 5F at that point — yet somehow it appears in the URL.

Below is the custom field code I wrote for reference:

PYTHONCopied
from collections import defaultdict
from typing import List, Dict, Any

import ulid
from django import forms
from django.core import checks
from django.core import exceptions
from django.db import models


class TablePrefixUlidPkField(models.UUIDField):
    empty_strings_allowed = False
    used_table_prefixes_to_fields: Dict[
        str, List['TablePrefixUlidPkField']
    ] = defaultdict(list)

    def __init__(self, table_prefix, *args, **kwargs):
        if not table_prefix:
            raise exceptions.ValidationError("Table Prefix cannot be empty.")
        if not isinstance(table_prefix, str):
            raise exceptions.ValidationError("Table Prefix must be a string.")

        self.table_prefix = table_prefix
        self.used_table_prefixes_to_fields[self.table_prefix].append(self)

        kwargs['default'] = self.table_prefixed_ulid_generator(table_prefix)
        kwargs['primary_key'] = True
        kwargs['editable'] = False
        kwargs['blank'] = True
        kwargs['db_comment'] = (
            "This field is a ULID being stored as a UUID. When used in the API (and "
            "everywhere outside the DB really), the ULID is shown with a "
            "table_prefix' prepended to it. When querying the DB directly you'll need "
            "to remove this prefix and confirm the ULID to UUIDs"
        )

        super().__init__(*args, **kwargs)

    @staticmethod
    def table_prefixed_ulid_generator(table_prefix: str):
        def new_ulid():
            return f"{table_prefix}_{ulid.new()}"

        return new_ulid

    def check(self, **kwargs):
        errors = super().check(**kwargs)

        if len(self.used_table_prefixes_to_fields[self.table_prefix]) > 1:
            errors.append(
                checks.Error(
                    f"Duplicate table prefix found: {self.table_prefix}",
                    hint="Change either table's prefix to not conflict.",
                    obj=self,
                    id="common.E001",
                )
            )

        return errors

    def get_db_prep_value(self, value, connection, prepared=False):
        _, ulid_obj = convert_value_to_known_forms(self.table_prefix, value)

        if ulid_obj is None:
            return None

        return super().get_db_prep_value(ulid_obj.uuid, connection, prepared)

    def from_db_value(self, value, expression, connection):
        return self.to_python(value)

    def to_python(self, value):
        string_value, _ = convert_value_to_known_forms(self.table_prefix, value)
        return string_value

    def formfield(self, **kwargs):
        defaults = {"form_class": table_prefix_form_field_factory(self.table_prefix)}
        defaults.update(kwargs)
        return super().formfield(**defaults)

    def deconstruct(self):
        name, path, args, kwargs = super().deconstruct()
        args.insert(0, self.table_prefix)

        # These fields are all forcibly set during __init__ 
        for field_name in (
                'default',
                'primary_key',
                'editable',
                'blank',
                'db_comment',
        ):
            if field_name in kwargs:
                del kwargs[field_name]
        return name, path, args, kwargs

def table_prefix_form_field_factory(outer_table_prefix):
    class TablePrefixUlidPkFormField(forms.CharField):
        table_prefix = outer_table_prefix

        def prepare_value(self, value):
            str_value, _ = convert_value_to_known_forms(self.table_prefix, value)
            return str_value

        def to_python(self, value):
            str_value, _ = convert_value_to_known_forms(self.table_prefix, value)
            return str_value

    return TablePrefixUlidPkFormField

def convert_value_to_known_forms(
        expected_table_prefix: str,
        input_value: Any
):  -> tuple[str | None, ulid.ULID | None]:
    if input_value is None:
        return None, None

    string_version = str(input_value)
    split = string_version.split("_")
    table_prefix = "_".join(split[:-1])
    ulid_string = split[-1]
    if table_prefix and table_prefix != expected_table_prefix:
        raise exceptions.ValidationError(
            'Invalid DB ID. Table prefix is incorrect; this ID likely does '
            'not belong to this table.',
            code='invalid',
        )

    try:
        parsed_ulid = ulid.parse(ulid_string)
    except (AttributeError, ValueError) as e:
        raise exceptions.ValidationError('Invalid DB ID.', code='invalid') from e

    display_string = f"{expected_table_prefix}_{parsed_ulid}"
    return display_string, parsed_ulid

I’d appreciate any suggestions for further debugging or insights into why this extra 5F appears in the URL.