django-field-logger 0.0.1__tar.gz

django-field-logger-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sergio Rodríguez
+
+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-field-logger-0.0.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+include README.md

django-field-logger-0.0.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: django-field-logger
+Version: 0.0.1
+Summary: A python package which logs each change made to a Django model instance.
+Home-page: https://github.com/nibblex/django-field-logger
+Author: Sergio Rodríguez
+Author-email: srodriguez3441@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+License-File: LICENSE

django-field-logger-0.0.1/README.md

@@ -0,0 +1,2 @@
+# django-field-logger
+A python package which logs each change made to a Django model instance.

django-field-logger-0.0.1/django_field_logger.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: django-field-logger
+Version: 0.0.1
+Summary: A python package which logs each change made to a Django model instance.
+Home-page: https://github.com/nibblex/django-field-logger
+Author: Sergio Rodríguez
+Author-email: srodriguez3441@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+License-File: LICENSE

django-field-logger-0.0.1/django_field_logger.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+django_field_logger.egg-info/PKG-INFO
+django_field_logger.egg-info/SOURCES.txt
+django_field_logger.egg-info/dependency_links.txt
+django_field_logger.egg-info/requires.txt
+django_field_logger.egg-info/top_level.txt
+fieldlogger/__init__.py
+fieldlogger/apps.py
+fieldlogger/config.py
+fieldlogger/fieldlogger.py
+fieldlogger/models.py
+fieldlogger/signals.py

django-field-logger-0.0.1/django_field_logger.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django-field-logger-0.0.1/django_field_logger.egg-info/requires.txt

@@ -0,0 +1 @@
+Django>=1.11

django-field-logger-0.0.1/django_field_logger.egg-info/top_level.txt

@@ -0,0 +1 @@
+fieldlogger

django-field-logger-0.0.1/fieldlogger/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class FieldloggerConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "fieldlogger"

django-field-logger-0.0.1/fieldlogger/config.py

@@ -0,0 +1,99 @@
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from json import JSONEncoder, JSONDecoder
+
+from django.conf import settings
+from django.db import models
+from django.utils.module_loading import import_string
+
+
+SETTINGS = getattr(settings, "FIELD_LOGGER_SETTINGS", {})
+
+
+class Encoder(JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, (date, datetime, time)):
+            return obj.isoformat()
+
+        if isinstance(obj, timedelta):
+            return obj.total_seconds()
+
+        if isinstance(obj, Decimal):
+            return str(obj)
+
+        if isinstance(obj, (bytes, bytearray)):
+            return obj.decode()
+
+        if isinstance(obj, memoryview):
+            return obj.tobytes().decode()
+
+        if isinstance(obj, models.Model):
+            return obj.pk
+
+        if isinstance(obj, models.QuerySet):
+            return list(obj.values_list("pk", flat=True))
+
+        return super().default(obj)
+
+
+class Decoder(JSONDecoder):
+    pass
+
+
+def logging_enabled(*configs):
+    return SETTINGS.get("LOGGING_ENABLED", True) and all(
+        config.get("logging_enabled", True) for config in configs
+    )
+
+
+def logging_fields(instance):
+    model_config = LOGGING_CONFIG.get(instance._meta.label, {})
+    logging_fields = model_config.get("fields", [])
+    if not logging_fields:
+        exclude_fields = model_config.get("exclude_fields", [])
+        logging_fields = [
+            field.name
+            for field in instance._meta.fields
+            if field.name not in exclude_fields
+        ]
+
+    return frozenset(logging_fields)
+
+
+def callbacks(*configs):
+    callbacks = SETTINGS.get("CALLBACKS", [])
+    for config in configs:
+        callbacks += config.get("callbacks", [])
+
+    callbacks = map(
+        lambda callback: import_string(callback)
+        if isinstance(callback, str)
+        else callback,
+        callbacks,
+    )
+
+    return list(callbacks)
+
+
+ENCODER = SETTINGS.get("ENCODER")
+ENCODER = import_string(ENCODER) if ENCODER else Encoder
+
+DECODER = SETTINGS.get("DECODER")
+DECODER = import_string(DECODER) if DECODER else Decoder
+
+LOGGING_APPS = SETTINGS.get("LOGGING_APPS", {})
+
+LOGGING_CONFIG = {}
+for app, app_config in LOGGING_APPS.items():
+    if not app_config or not logging_enabled(SETTINGS, app_config):
+        continue
+
+    for model, model_config in app_config.get("models", {}).items():
+        if not model_config or not logging_enabled(SETTINGS, app_config, model_config):
+            continue
+
+        model_config.update(
+            {"callbacks": callbacks(SETTINGS, app_config, model_config)}
+        )
+
+        LOGGING_CONFIG[f"{app}.{model}"] = model_config

django-field-logger-0.0.1/fieldlogger/fieldlogger.py

@@ -0,0 +1,53 @@
+from django.core.exceptions import FieldDoesNotExist
+
+# Helpers
+
+
+def rgetattr(obj, attr, *args):
+    from functools import reduce
+
+    def _getattr(obj, attr):
+        return getattr(obj, attr, *args)
+
+    return reduce(_getattr, [obj] + attr.split("."))
+
+
+def rsetattr(obj, attr, val, save=False):
+    pre, _, post = attr.rpartition(".")
+    obj_to_save = rgetattr(obj, pre) if pre else obj
+    setattr(obj_to_save, post, val)
+    if save:
+        obj_to_save.save(update_fields=[post])
+
+
+# Main function
+
+
+def log_fields(instance, fields):
+    logs = {}
+
+    pre_instance = instance.__class__.objects.get(pk=instance.pk)
+
+    for field in fields:
+        try:
+            field_model = instance._meta.get_field(field)
+            new_value = field_model.to_python(rgetattr(instance, field))
+            old_value = rgetattr(pre_instance, field)
+        except (FieldDoesNotExist, AttributeError):
+            continue
+
+        if new_value == old_value:
+            continue
+
+        logs[field] = instance.field_logs.create(
+            app_label=instance._meta.app_label,
+            model=instance._meta.model_name,
+            object_id=instance.pk,
+            field=field,
+            old_value=old_value,
+            new_value=new_value,
+        )
+
+        rsetattr(instance, field, new_value)
+
+    return logs

django-field-logger-0.0.1/fieldlogger/models.py

@@ -0,0 +1,57 @@
+from django.apps import apps
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+
+from .config import ENCODER, DECODER
+
+
+class FieldLog(models.Model):
+    app_label = models.CharField(max_length=100, editable=False)
+    model = models.CharField(_("model class name"), max_length=100, editable=False)
+    object_id = models.PositiveIntegerField(editable=False)
+    field = models.CharField(_("field name"), max_length=100, editable=False)
+    old_value = models.JSONField(
+        encoder=ENCODER, decoder=DECODER, blank=True, null=True, editable=False
+    )
+    timestamp = models.DateTimeField(auto_now=True, editable=False)
+    new_value = models.JSONField(
+        encoder=ENCODER, decoder=DECODER, blank=True, null=True, editable=False
+    )
+    extra_data = models.JSONField(default=dict)
+
+    def __str__(self):
+        return f"({self.field}) {self.old_value} -> {self.new_value}"
+
+    @classmethod
+    def from_db(cls, db, field_names, values):
+        field_class = apps.get_model(values[1], values[2])._meta.get_field(values[4])
+        instance = super().from_db(db, field_names, values)
+        instance.old_value = field_class.to_python(instance.old_value)
+        instance.new_value = field_class.to_python(instance.new_value)
+        return instance
+
+    @property
+    def model_class(self):
+        return apps.get_model(self.app_label, self.model)
+
+    @property
+    def instance(self):
+        return self.model_class.objects.get(pk=self.object_id)
+
+    @property
+    def previous_log(self):
+        return (
+            self.__class__.objects.filter(
+                app_label=self.app_label,
+                model=self.model,
+                object_id=self.object_id,
+                field=self.field,
+            )
+            .exclude(pk=self.pk)
+            .order_by("-pk")
+            .last()
+        )
+
+    @property
+    def created(self):
+        return not self.previous_log

django-field-logger-0.0.1/fieldlogger/signals.py

@@ -0,0 +1,26 @@
+from django.db.models.signals import pre_save
+
+from .config import LOGGING_CONFIG, logging_fields
+from .fieldlogger import log_fields
+
+
+def log_dirty_fields(sender, instance, *args, **kwargs):
+    if instance.pk:
+        using_fields = logging_fields(instance)
+
+        update_fields = kwargs["update_fields"] or frozenset()
+        if update_fields:
+            using_fields = using_fields & update_fields
+
+        if using_fields:
+            logs = log_fields(instance, using_fields)
+            if logs and "timestamps" not in update_fields:
+                kwargs["update_fields"] = update_fields | frozenset(["timestamps"])
+
+            callbacks = LOGGING_CONFIG[sender._meta.label].get("callbacks", [])
+            for callback in callbacks:
+                callback(instance, using_fields, logs)
+
+
+for label in LOGGING_CONFIG:
+    pre_save.connect(log_dirty_fields, label)

django-field-logger-0.0.1/setup.cfg

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

django-field-logger-0.0.1/setup.py

@@ -0,0 +1,24 @@
+import os
+import setuptools
+
+# allow setup.py to be run from any path
+os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
+
+setuptools.setup(
+    name="django-field-logger",
+    version="0.0.1",
+    author="Sergio Rodríguez",
+    author_email="srodriguez3441@gmail.com",
+    description="""A python package which logs each change made to a Django model instance.""",
+    url="https://github.com/nibblex/django-field-logger",
+    packages=setuptools.find_packages(),
+    license="MIT",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    install_requires=[
+        "Django>=1.11",
+    ],
+)