Something akin to Django's deconstruct for filters?

[rtpg]

While working on a fairly hefty API refactor, I'm trying to track some changes in our filter code.

I've ended up doing something like the following:

BASE_FILTER_FIELD_DEFAULTS = {
    "lookup_expr": "exact",
    "label": None,
    "distinct": False,
    "exclude": False,
}


def base_serialize_filter_definition(filter):
    if filter.method is None:
        # django-filters types are wrong
        method_name = None  # type: ignore[unreachable]
    elif isinstance(filter.method, str):
        # again, django-filters types are wrong
        method_name = filter.method  # type: ignore[unreachable]
    else:
        method_name = f"{filter.method.__module__}.{filter.method.__qualname__}"

    result = {
        "filter_class": filter.__class__.__name__,
        "filter_name": filter.field_name,
    }
    # some base filter args are rarely included, so we include them only if they
    # are not like the default
    if method_name is not None:
        result["method"] = method_name
    for key, default_value in BASE_FILTER_FIELD_DEFAULTS.items():
        if getattr(filter, key) != default_value:
            result[key] = getattr(filter, key)
    return result
filters.Filter.serialize_definition = base_serialize_filter_definition

On top of that, custom filter subclasses do something like the following:

class NewFilter(filters.Filter):
    def __init__(self, new_arg, *args, **kwargs):
      self.new_arg = new_arg
      super().__init__(*args, **kwargs)

  def serialize_definition(self):
      serialized = super().serialize_definition()
      serialized["new_arg"] = new_arg
      return serialized

idea being that I can then serialize a filterset down to something looking like a filter spec by calling filter.serialize_definition() and capturing most of the init args and whatnot, like Django model field's deconstruct.

Main thing though is that while I want deconstruct, I don't particularly otherwise need library support for generating a spec or something like that. That involves decisions I'm not prepared to tackle. But I have to imagine I'm not the only one looking to dump out FilterSets to some diffable format

[carltongibson]

Hi @rtpg — Nice example thanks.

Not sure that we have a full story to justify it but could be the start of a django_filters.inspect.

[rtpg]

Right, if there was an inspect submodule I could see people relying on it for spec generation work. Theoretically.

Right now in my implementation I serialize the arguments like the method name but that serialization isn't even necessary (consumers could handle that step as people's needs are different).

Wish my usage was something a bit straightforward so I could have a downstream feature request to motivate this.