django-genfkadmin 0.1.0__py3-none-any.whl

django_genfkadmin-0.1.0.dist-info/METADATA

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: django-genfkadmin
+Version: 0.1.0
+Summary: No frills GenericForeignKeys for your Django Admin
+Author-email: Michael Spallino <mikehspallino@gmail.com>
+Maintainer-email: Michael Spallino <mikehspallino@gmail.com>
+Project-URL: Homepage, https://github.com/mikespallino/django-genericfkadmin
+Project-URL: Issues, https://github.com/mikespallino/django-genericfkadmin/issues
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: Django :: 5
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=5
+Dynamic: license-file
+
+# Django GenericFKAdmin
+
+Using `GenericForeignKey` in your Django models is cool, the default behavior of
+Django Admin is not. This package allows you to replace the `content_type` and
+`object_id` fields in your admin forms with a single input that is prefilled
+with only the models related through `GenericRelation` fields.
+
+## Setup
+
+### Install
+
+```shell
+pip install django-genfkadmin
+````
+
+```shell
+uv add django-genfkadmin
+```
+
+### Usage
+
+Using this package is pretty simple.
+
+1. Create a subclass of `GenericFKModelForm` for your model.
+2. Create a subclass of `GenericFKAdmin` for your model.
+3. ???
+4. Profit!
+
+e.g. in your `admin.py`
+```python
+from genfkadmin.admin import GenericFKAdmin
+from genfkadmin.forms import GenericFKModelForm
+
+
+class PetAdminForm(GenericFKModelForm):
+
+    class Meta:
+        model = Pet
+        fields = "__all__"
+
+
+@admin.register(Pet)
+class PetAdmin(GenericFKAdmin):
+    form = PetAdminForm
+```
+
+![example](docs/screenshots/example_admin.png)
+
+A complete example django app exists in this repository at [here](/example)
+
+
+## Roadmap
+1. Implement a filtering callback to further restrict the set of options available in the selector
+2. Stacked and Tabular Inline support.

django_genfkadmin-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+django_genfkadmin-0.1.0.dist-info/licenses/LICENSE,sha256=Y-5z4chfgv5qhkHMNGH6dldXHzvqelRsjbE5MGLOkTo,1073
+genfkadmin/__init__.py,sha256=hdYh7PI60aPJY8BkokR04Mxo2TCZUOUlA6Zzt765na0,91
+genfkadmin/admin.py,sha256=nlEGMqvFd5tneS_an04Ws6Dp8lXoZ8N0zPwdAo5KD5I,3393
+genfkadmin/fields.py,sha256=pJeoZsAq1L6HvrTgShoZmPMJJiddZ9-RSqc0neeTJTI,1711
+genfkadmin/forms.py,sha256=w_-xK0m-2NFgplOBqnQ3SvHlJs78Y_dpmyVlmzyHhHU,3390
+django_genfkadmin-0.1.0.dist-info/METADATA,sha256=Cyr7c32vs-IeBPVuQCu0kQc228NKIMmlGZayowjg20M,2199
+django_genfkadmin-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+django_genfkadmin-0.1.0.dist-info/top_level.txt,sha256=AD-AF3VAfg620J8v6cGkBScRdx9o3qAj_lX-BbL0SV4,11
+django_genfkadmin-0.1.0.dist-info/RECORD,,

django_genfkadmin-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_genfkadmin-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Michael Spallino
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_genfkadmin-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+genfkadmin

genfkadmin/__init__.py

@@ -0,0 +1,2 @@
+FIELD_ID_FORMAT = "{app_label}${model_name}[{pk}]"
+GENERIC_FIELD_NAME = "{field_name}_gfk"

genfkadmin/admin.py

@@ -0,0 +1,90 @@
+import copy
+
+from django.contrib import admin
+from django.contrib.contenttypes.fields import GenericForeignKey
+
+from genfkadmin import GENERIC_FIELD_NAME
+from genfkadmin.forms import GenericFKModelForm
+
+
+class GenericFKAdmin(admin.ModelAdmin):
+    """
+    A ModelAdmin for use with a Model that utilizes GenericForeignKeys.
+    """
+
+    form = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # store a mapping of our GenericForeignKeys to their content_type and
+        # foreign_key fields
+        self.generic_fields = {}
+        self.generic_related_fields = set()
+        for field in self.model._meta.private_fields:
+            if isinstance(field, GenericForeignKey):
+                self.generic_fields[
+                    GENERIC_FIELD_NAME.format(field_name=field.name)
+                ] = {
+                    "ct_field": field.ct_field,
+                    "fk_field": field.fk_field,
+                }
+                self.generic_related_fields.add(field.ct_field)
+                self.generic_related_fields.add(field.fk_field)
+
+    def get_fields(self, *args, **kwargs):
+        """
+        Overrides get_fields to remove content_type and foreign_key fields for
+        the GenericForeignKey and replaces them with the dynamic fields.
+        """
+        updated_fields_with_generic_keys = []
+
+        if self.fields:
+            # if we have fields already make sure the content type and foreign
+            # key fields aren't present and add our generic fields
+            updated_fields_with_generic_keys = copy.deepcopy(self.fields)
+            for field, generic_related_fields in self.generic_fields.items():
+                try:
+                    updated_fields_with_generic_keys.remove(
+                        generic_related_fields["ct_field"]
+                    )
+                    updated_fields_with_generic_keys.remove(
+                        generic_related_fields["fk_field"]
+                    )
+                    updated_fields_with_generic_keys.append(field)
+                except ValueError:
+                    pass
+        else:
+            # if we don't have fields generate them ourselves, including the
+            # dynamic generic foreign key fields
+            for field in self.model._meta.fields:
+                if (
+                    not field.primary_key
+                    and field.name not in self.generic_related_fields
+                ):
+                    updated_fields_with_generic_keys.append(field.name)
+            for generic_field in self.generic_fields:
+                updated_fields_with_generic_keys.append(generic_field)
+        return updated_fields_with_generic_keys
+
+    def get_form(self, *args, **kwargs):
+        """
+        Overrides get_form to return our subclassed GenericFKModelForm.
+        """
+        # bypass any auto form generation by simply returning the form
+        # attribute and do some gut checks to make sure we have an appropriate
+        # form to use
+        if not self.form:
+            raise NotImplementedError(
+                "Must define self.form that inherits from "
+            )
+        if not issubclass(self.form, GenericFKModelForm):
+            raise NotImplementedError(
+                "self.form must be subclass of GenericFKModelForm"
+            )
+        return self.form
+
+
+__all__ = [
+    "GenericFKAdmin",
+]

genfkadmin/fields.py

@@ -0,0 +1,52 @@
+from django import forms
+from django.contrib.contenttypes.fields import GenericRelation
+
+from genfkadmin import FIELD_ID_FORMAT
+
+
+class GenericFKField(forms.ChoiceField):
+    """
+    A ChoiceField that generates it's set of choices based on the related
+    models for the GenericForeignKey Relations.
+    """
+
+    def __init__(self, model, *args, **kwargs):
+        """
+        Given a model and an optional, initialize the set of
+        choices that should be available for this field.
+        """
+        choices = []
+
+        # generic relations are stored in _relation_tree, so we can grab
+        # the models from those relations and develop a set of choices
+        # for the select input. The value of the choice is a formatted string
+        # FIELD_ID_FORMAT, that stores the necessary information to parse
+        # back out in the form on save to grab the content_type_id and
+        # object_id of the selected value.
+        for relation in model._meta._relation_tree:
+            if isinstance(relation, GenericRelation):
+                queryset = relation.model.objects.all()
+                choices.extend(
+                    [
+                        (
+                            FIELD_ID_FORMAT.format(
+                                app_label=i._meta.app_label,
+                                model_name=i._meta.model_name,
+                                pk=i.pk,
+                            ),
+                            str(i),
+                        )
+                        for i in queryset
+                    ]
+                )
+
+        super().__init__(
+            *args,
+            choices=choices,
+            **kwargs,
+        )
+
+
+__all__ = [
+    "GenericFKField",
+]

genfkadmin/forms.py

@@ -0,0 +1,82 @@
+from django import forms
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+
+from genfkadmin import FIELD_ID_FORMAT, GENERIC_FIELD_NAME
+from genfkadmin.fields import GenericFKField
+
+
+class GenericFKModelForm(forms.ModelForm):
+    """
+    A ModelForm that automatically replaces the content type and foreign key
+    fields of GenericForeignKeys with a single input supplies options for all
+    the models with GenericRelations.
+    """
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+        self.generic_fields = {}
+
+        # private_fields has GenericForeignKeys, so we check for those here
+        # and inject a fake field into the form. We also remove the
+        # content_type and foreign_key fields if they exist on the declared
+        # fields of the form so that we only have the generic field.
+        for field in self._meta.model._meta.private_fields:
+            if isinstance(field, GenericForeignKey):
+                # we must name the generic field something other than the
+                # original name, because GenericForeignKey are editable=False
+                # and won't be allowed in the form
+                generic_field_name = GENERIC_FIELD_NAME.format(
+                    field_name=field.name
+                )
+                self.generic_fields[generic_field_name] = {
+                    "ct_field": field.ct_field,
+                    "fk_field": field.fk_field,
+                }
+                self.fields.pop(field.ct_field, None)
+                self.fields.pop(field.fk_field, None)
+                self.fields[generic_field_name] = GenericFKField(
+                    field.model,
+                    label=field.name,
+                )
+
+    def get_initial_for_field(self, field, field_name):
+        # generate the initial value for any of the generic fields so that
+        # the correct choice is auto selected
+        if field_name in self.generic_fields:
+            target_instance = self.instance.content_object
+            if target_instance:
+                return FIELD_ID_FORMAT.format(
+                    app_label=target_instance._meta.app_label,
+                    model_name=target_instance._meta.model_name,
+                    pk=target_instance.pk,
+                )
+        return super().get_initial_for_field(field, field_name)
+
+    def save(self, commit=True):
+        instance = super().save(commit=commit)
+
+        # for the generic fields, we parse the value out of FIELD_ID_FORMAT
+        # which gives us the ability to query for the ContentType and get the
+        # primary key of the related field. We use setattr to update these
+        # values dynamically
+        for generic_field, related_fields in self.generic_fields.items():
+            target_model_instance = self.cleaned_data[generic_field]
+            app_label, rest = target_model_instance.split("$")
+            model_name, dirty_id = rest.split("[")
+
+            content_type = ContentType.objects.get(
+                app_label=app_label, model=model_name
+            )
+            object_id = dirty_id.strip("[").strip("]")
+
+            setattr(instance, related_fields["ct_field"], content_type)
+            setattr(instance, related_fields["fk_field"], object_id)
+
+        return instance
+
+
+__all__ = [
+    "GenericFKModelForm",
+]