Modernize for Python 3.14 and Django 5-6

Author: Test User

.github/workflows/publish.yaml

@@ -0,0 +1,34 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    name: Build and Publish to PyPI
+    runs-on: ubuntu-latest
+    environment: pypi
+
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.14"
+
+      - name: Install build tools
+        run: python -m pip install --upgrade pip build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.egg-info/
+*.pyc
+.coverage
+.ruff_cache/
+.pyright/
+dist/
+build/

.python-version

@@ -0,0 +1 @@
+3.14

README.rst

@@ -2,39 +2,36 @@
 django-model-changes
 ====================
 
-Please note: django-model-changes does not support Python3.0+. A fork is maintained at https://github.com/iansprice/django-model-changes-py3 for Python3.3+ and can be installed via `pip install django-model-changes-py3`. 
+django-model-changes allows you to track the state and changes of a model instance.
 
-django-model-changes allows you to track the state and changes of a model instance:
+**Requirements:** Python 3.14+, Django 5.0-6.x
 
 Quick start
 -----------
 
 1. Install django-model-changes::
 
-    pip install django-model-changes
+    uv add django-model-changes
 
-2. Add "django_model_changes" to your INSTALLED_APPS setting like this::
+   Or with pip::
 
-    INSTALLED_APPS = (
-        ...
-        'django_model_changes',
-    )
+    pip install django-model-changes
 
-3. Add the `ChangesMixin` to your model::
+2. Add the ``ChangesMixin`` to your model::
 
     >>> from django.db import models
     >>> from django_model_changes import ChangesMixin
 
     >>> class User(ChangesMixin, models.Model):
     >>>     name = models.CharField(max_length=100)
 
-4. Get instance changes::
+3. Get instance changes::
 
     >>> user = User()
     >>> user.name = 'Foo Bar'
     >>> user.save()
 
-    >>> user.name 'I got a new name'
+    >>> user.name = 'I got a new name'
 
     >>> # Get current state
     >>> user.current_state()
@@ -64,10 +61,10 @@ Quick start
     >>> user.is_persisted()
     True
 
-5. Listen for changes::
-        
+4. Listen for changes::
+
    >>> from django_model_changes import post_change
-    
+
    >>> def my_callback(sender, instance, **kwargs):
    >>>     # Do something with previous and current state
    >>>     instance.old_state()

django_model_changes/__init__.py

@@ -1,2 +1,5 @@
 from .changes import ChangesMixin
 from .signals import post_change
+from ._version import __version__
+
+__all__ = ["ChangesMixin", "post_change", "__version__"]

django_model_changes/_version.py

@@ -0,0 +1,6 @@
+"""Version information for django-model-changes.
+
+This file is automatically updated by `djb publish`.
+"""
+
+__version__ = "1.0.0"

django_model_changes/changes.py

@@ -1,13 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from django.db import models
 from django.db.models import signals
 
 from .signals import post_change
 
+if TYPE_CHECKING:
+    from django.db.models.options import Options
+
 SAVE = 0
 DELETE = 1
 
 
-class ChangesMixin(object):
-    """
+class ChangesMixin(models.Model):
+    r"""
     ChangesMixin keeps track of changes for model instances.
 
     It allows you to retrieve the following states from an instance:
@@ -61,22 +69,29 @@ class ChangesMixin(object):
 
     """
 
-    def __init__(self, *args, **kwargs):
-        super(ChangesMixin, self).__init__(*args, **kwargs)
+    _states: list[dict[str, Any]]
+
+    class Meta:
+        abstract = True
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
 
         self._states = []
         self._save_state(new_instance=True)
 
         signals.post_save.connect(
-            _post_save, sender=self.__class__,
-            dispatch_uid='django-changes-%s' % self.__class__.__name__
+            _post_save,
+            sender=self.__class__,
+            dispatch_uid=f"django-changes-{self.__class__.__name__}",
         )
         signals.post_delete.connect(
-            _post_delete, sender=self.__class__,
-            dispatch_uid='django-changes-%s' % self.__class__.__name__
+            _post_delete,
+            sender=self.__class__,
+            dispatch_uid=f"django-changes-{self.__class__.__name__}",
         )
 
-    def _save_state(self, new_instance=False, event_type='save'):
+    def _save_state(self, new_instance: bool = False, event_type: str | int = "save") -> None:
         # Pipe the pk on deletes so that a correct snapshot of the current
         # state can be taken.
         if event_type == DELETE:
@@ -95,58 +110,60 @@ def _save_state(self, new_instance=False, event_type='save'):
         if not new_instance:
             post_change.send(sender=self.__class__, instance=self)
 
-    def current_state(self):
+    def current_state(self) -> dict[str, Any]:
         """
         Returns a ``field -> value`` dict of the current state of the instance.
         """
-        field_names = set()
-        [field_names.add(f.name) for f in self._meta.local_fields]
-        [field_names.add(f.attname) for f in self._meta.local_fields]
-        return dict([(field_name, getattr(self, field_name)) for field_name in field_names])
+        field_names: set[str] = set()
+        for f in self._meta.local_fields:
+            field_names.add(f.name)
+            field_names.add(f.attname)
+        return {field_name: getattr(self, field_name) for field_name in field_names}
 
-    def previous_state(self):
+    def previous_state(self) -> dict[str, Any]:
         """
         Returns a ``field -> value`` dict of the state of the instance after it
         was created, saved or deleted the previous time.
         """
         if len(self._states) > 1:
             return self._states[1]
-        else:
-            return self._states[0]
+        return self._states[0]
 
-    def old_state(self):
+    def old_state(self) -> dict[str, Any]:
         """
         Returns a ``field -> value`` dict of the state of the instance after
         it was created, saved or deleted the previous previous time. Returns
         the previous state if there is no previous previous state.
         """
         return self._states[0]
 
-    def _changes(self, other, current):
-        return dict([(key, (was, current[key])) for key, was in other.iteritems() if was != current[key]])
+    def _changes(
+        self, other: dict[str, Any], current: dict[str, Any]
+    ) -> dict[str, tuple[Any, Any]]:
+        return {key: (was, current[key]) for key, was in other.items() if was != current[key]}
 
-    def changes(self):
+    def changes(self) -> dict[str, tuple[Any, Any]]:
         """
         Returns a ``field -> (previous value, current value)`` dict of changes
         from the previous state to the current state.
         """
         return self._changes(self.previous_state(), self.current_state())
 
-    def old_changes(self):
+    def old_changes(self) -> dict[str, tuple[Any, Any]]:
         """
         Returns a ``field -> (previous value, current value)`` dict of changes
         from the old state to the current state.
         """
         return self._changes(self.old_state(), self.current_state())
 
-    def previous_changes(self):
+    def previous_changes(self) -> dict[str, tuple[Any, Any]]:
         """
         Returns a ``field -> (previous value, current value)`` dict of changes
         from the old state to the previous state.
         """
         return self._changes(self.old_state(), self.previous_state())
 
-    def was_persisted(self):
+    def was_persisted(self) -> bool:
         """
         Returns true if the instance was persisted (saved) in its old
         state.
@@ -163,10 +180,12 @@ def was_persisted(self):
             >>> user.was_persisted()
             True
         """
-        pk_name = self._meta.pk.name
-        return bool(self.old_state()[pk_name])
+        pk_field = self._meta.pk
+        if pk_field is None:
+            return False
+        return bool(self.old_state()[pk_field.name])
 
-    def is_persisted(self):
+    def is_persisted(self) -> bool:
         """
         Returns true if the instance is persisted (saved) in its current
         state.
@@ -185,22 +204,22 @@ def is_persisted(self):
         """
         return bool(self.pk)
 
-    def old_instance(self):
+    def old_instance(self) -> ChangesMixin:
         """
         Returns an instance of this model in its old state.
         """
         return self.__class__(**self.old_state())
 
-    def previous_instance(self):
+    def previous_instance(self) -> ChangesMixin:
         """
         Returns an instance of this model in its previous state.
         """
         return self.__class__(**self.previous_state())
 
 
-def _post_save(sender, instance, **kwargs):
+def _post_save(sender: type[models.Model], instance: ChangesMixin, **kwargs: Any) -> None:
     instance._save_state(new_instance=False, event_type=SAVE)
 
 
-def _post_delete(sender, instance, **kwargs):
+def _post_delete(sender: type[models.Model], instance: ChangesMixin, **kwargs: Any) -> None:
     instance._save_state(new_instance=False, event_type=DELETE)