django-genfkadmin 0.1.0__tar.gz

django_genfkadmin-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,54 @@
+# 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/django_genfkadmin.egg-info/PKG-INFO

@@ -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/django_genfkadmin.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+django_genfkadmin.egg-info/PKG-INFO
+django_genfkadmin.egg-info/SOURCES.txt
+django_genfkadmin.egg-info/dependency_links.txt
+django_genfkadmin.egg-info/requires.txt
+django_genfkadmin.egg-info/top_level.txt
+genfkadmin/__init__.py
+genfkadmin/admin.py
+genfkadmin/fields.py
+genfkadmin/forms.py
+tests/test_admin.py
+tests/test_fields.py
+tests/test_forms.py

django_genfkadmin-0.1.0/django_genfkadmin.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_genfkadmin-0.1.0/django_genfkadmin.egg-info/requires.txt

@@ -0,0 +1 @@
+django>=5

django_genfkadmin-0.1.0/django_genfkadmin.egg-info/top_level.txt

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

django_genfkadmin-0.1.0/genfkadmin/__init__.py

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

django_genfkadmin-0.1.0/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",
+]

django_genfkadmin-0.1.0/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",
+]

django_genfkadmin-0.1.0/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",
+]

django_genfkadmin-0.1.0/pyproject.toml

@@ -0,0 +1,59 @@
+[project]
+name = "django-genfkadmin"
+version = "0.1.0"
+description = "No frills GenericForeignKeys for your Django Admin"
+readme = "README.md"
+authors = [
+  {name = "Michael Spallino", email = "mikehspallino@gmail.com"},
+]
+maintainers = [
+  {name = "Michael Spallino", email = "mikehspallino@gmail.com"},
+]
+license-files = ["LICENSE"]
+classifiers = [
+  "Development Status :: 2 - Pre-Alpha",
+  "Intended Audience :: Developers",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Software Development :: Libraries :: Application Frameworks",
+  "License :: OSI Approved :: MIT License",
+  "Framework :: Django :: 5",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.11",
+  "Operating System :: OS Independent"
+]
+requires-python = ">=3.11"
+dependencies = [
+    "django>=5",
+]
+
+[project.urls]
+Homepage = "https://github.com/mikespallino/django-genericfkadmin"
+Issues = "https://github.com/mikespallino/django-genericfkadmin/issues"
+
+[tool.black]
+line-length = 80
+
+[tool.isort]
+profile = "black"
+
+[tool.uv.sources]
+django-genfkadmin = { workspace = true }
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = [
+    "tests/",
+]
+addopts = "--create-db --no-migrations"
+
+[dependency-groups]
+dev = [
+    "autoflake>=2.3.1",
+    "black>=25.1.0",
+    "factory-boy>=3.3.3",
+    "isort>=6.0.1",
+    "pre-commit>=4.3.0",
+    "pytest>=8.4.2",
+    "pytest-django>=4.11.1",
+    "twine>=6.2.0",
+]

django_genfkadmin-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_genfkadmin-0.1.0/tests/test_admin.py

@@ -0,0 +1,80 @@
+import pytest
+from django import forms
+
+from genfkadmin.admin import GenericFKAdmin
+from genfkadmin.forms import GenericFKModelForm
+from tests.models import Pet
+
+
+class BadAdminConfiguration(GenericFKAdmin):
+    pass
+
+
+def test_admin_must_define_form():
+    from django.contrib.admin import site
+
+    with pytest.raises(NotImplementedError):
+        admin = BadAdminConfiguration(Pet, site)
+        admin.get_form()
+
+
+class BadForm(forms.ModelForm):
+    class Meta:
+        model = Pet
+        fields = "__all__"
+
+
+def test_admin_form_must_subclass():
+    from django.contrib.admin import site
+
+    with pytest.raises(NotImplementedError):
+        BadAdminConfiguration.form = BadForm
+        admin = BadAdminConfiguration(Pet, site)
+        admin.get_form()
+
+
+class GoodForm(GenericFKModelForm):
+
+    class Meta:
+        model = Pet
+        fields = "__all__"
+
+
+class GoodAdminConfiguration(GenericFKAdmin):
+    form = GoodForm
+
+
+def test_admin_stores_generic_fields():
+    from django.contrib.admin import site
+
+    admin = GoodAdminConfiguration(Pet, site)
+
+    assert "content_object_gfk" in admin.generic_fields
+    assert (
+        admin.generic_fields["content_object_gfk"]["ct_field"] == "content_type"
+    )
+    assert admin.generic_fields["content_object_gfk"]["fk_field"] == "object_id"
+
+
+def test_admin_stores_generic_related_fields():
+    from django.contrib.admin import site
+
+    admin = GoodAdminConfiguration(Pet, site)
+    assert admin.generic_related_fields == {"content_type", "object_id"}
+
+
+def test_admin_default_field_config_removes_generic_related_fields():
+    from django.contrib.admin import site
+
+    admin = GoodAdminConfiguration(Pet, site)
+    fields = admin.get_fields()
+    assert admin.generic_related_fields & set(fields) == set()
+
+
+def test_admin_removes_generic_related_fields_when_fields_defined():
+    from django.contrib.admin import site
+
+    admin = GoodAdminConfiguration(Pet, site)
+    admin.fields = ["owner", "content_type", "object_id"]
+    fields = admin.get_fields()
+    assert admin.generic_related_fields & set(fields) == set()

django_genfkadmin-0.1.0/tests/test_fields.py

@@ -0,0 +1,49 @@
+import pytest
+
+from genfkadmin import FIELD_ID_FORMAT
+from genfkadmin.fields import GenericFKField
+from tests.factories import ElephantFactory
+from tests.models import Pet
+
+
+@pytest.mark.django_db
+def test_field_has_choices(pets):
+    field = GenericFKField(Pet)
+    assert field.choices is not None
+
+
+@pytest.mark.django_db
+def test_field_choices_value_format(pets):
+    expected_values = []
+    for dog in pets["dogs"]:
+        expected_values.append(
+            FIELD_ID_FORMAT.format(
+                app_label="tests", model_name="dog", pk=dog.pk
+            )
+        )
+    for cat in pets["cats"]:
+        expected_values.append(
+            FIELD_ID_FORMAT.format(
+                app_label="tests", model_name="cat", pk=cat.pk
+            )
+        )
+
+    field = GenericFKField(Pet)
+    for value, display in field.choices:
+        assert value in expected_values
+
+
+@pytest.mark.django_db
+def test_field_choices_only_linked_models(pets):
+    elephants = [ElephantFactory() for _ in range(3)]
+
+    field = GenericFKField(Pet)
+    elephant_choices = [
+        FIELD_ID_FORMAT.format(
+            app_label="tests", model_name="elephant", pk=el.pk
+        )
+        for el in elephants
+    ]
+
+    for value, display in field.choices:
+        assert value not in elephant_choices

django_genfkadmin-0.1.0/tests/test_forms.py

@@ -0,0 +1,68 @@
+import pytest
+from django.contrib.contenttypes.models import ContentType
+
+from genfkadmin import FIELD_ID_FORMAT
+from genfkadmin.fields import GenericFKField
+from genfkadmin.forms import GenericFKModelForm
+from tests.models import Cat, Dog, Pet
+
+
+class PetAdminForm(GenericFKModelForm):
+
+    class Meta:
+        model = Pet
+        fields = "__all__"
+
+
+@pytest.mark.django_db
+def test_form_detects_generic_fields():
+    form = PetAdminForm()
+
+    assert "content_object_gfk" in form.generic_fields
+    assert (
+        form.generic_fields["content_object_gfk"]["ct_field"] == "content_type"
+    )
+    assert form.generic_fields["content_object_gfk"]["fk_field"] == "object_id"
+
+
+@pytest.mark.django_db
+def test_form_removes_content_type_and_fk_fields():
+    form = PetAdminForm()
+
+    assert "content_object_gfk" in form.fields
+    assert "content_type" not in form.fields
+    assert "object_id" not in form.fields
+
+
+@pytest.mark.django_db
+def test_form_populates_initial_value(pets):
+    instance = pets["pets"][0]
+    dog = pets["dogs"][0]
+    form = PetAdminForm(instance=instance)
+    assert form.get_initial_for_field(
+        GenericFKField, "content_object_gfk"
+    ) == FIELD_ID_FORMAT.format(app_label="tests", model_name="dog", pk=dog.pk)
+
+
+@pytest.mark.django_db
+def test_form_save_updates_content_type_and_fk_fields(pets):
+    instance = pets["pets"][0]
+    assert instance.content_type == ContentType.objects.get_for_model(Dog)
+    assert instance.content_object == pets["dogs"][0]
+
+    cat = pets["cats"][0]
+    form = PetAdminForm(
+        data={
+            "owner": instance.owner,
+            "content_object_gfk": FIELD_ID_FORMAT.format(
+                app_label="tests", model_name="cat", pk=cat.pk
+            ),
+        },
+        instance=instance,
+    )
+    updated_instance = form.save()
+
+    assert updated_instance.content_type == ContentType.objects.get_for_model(
+        Cat
+    )
+    assert updated_instance.content_object == cat