internal refactoring and deprecations

python 3.2 & django 1.5c1 compatibility

Author: saxix

.travis.yml

@@ -5,11 +5,12 @@ services:
 python:
   - "2.6"
   - "2.7"
+  - "3.2"
 env:
-  - DJANGO="Django==1.4.3" DBENGINE=sqlite
+#  - DJANGO="Django==1.4.3" DBENGINE=sqlite
   - DJANGO="Django==1.4.3" DBENGINE=mysql
   - DJANGO="Django==1.4.3" DBENGINE=pg
-  - DJANGO=https://www.djangoproject.com/download/1.5c1/tarball/ DBENGINE=mysql
+#  - DJANGO=https://www.djangoproject.com/download/1.5c1/tarball/ DBENGINE=mysql
   - DJANGO=https://www.djangoproject.com/download/1.5c1/tarball/ DBENGINE=pg
   - DJANGO=https://www.djangoproject.com/download/1.5c1/tarball/ DBENGINE=sqlite
 install:

concurrency/__init__.py

@@ -47,4 +47,3 @@ def get_git_changeset():
         return None
     return timestamp.strftime('%Y%m%d%H%M%S')
 
-

concurrency/api.py

@@ -1,10 +1,29 @@
 # -*- coding: utf-8 -*-
+import logging
 from django.core.exceptions import ImproperlyConfigured
+from concurrency.core import _wrap_save, _select_lock, _wrap_model_save
 
-from django.utils.translation import gettext as _
-from concurrency.core import _wrap_save, _select_lock
+__all__ = ['apply_concurrency_check', 'concurrency_check', 'get_revision_of_object']
 
-__all__ = ['apply_concurrency_check', 'concurrency_check']
+logger = logging.getLogger('concurrency')
+
+
+def get_revision_of_object(obj):
+    """
+
+    @param obj:
+    @return:
+    """
+    revision_field = obj.RevisionMetaInfo.field
+    value = getattr(obj, revision_field.attname)
+    return value
+
+
+def is_changed(obj):
+    revision_field = obj.RevisionMetaInfo.field
+    version = getattr(obj, revision_field.attname)
+    return not obj.__class__.objects.filter(**{obj._meta.pk.name:obj.pk,
+                                           revision_field.attname: version}).exists()
 
 
 def apply_concurrency_check(model, fieldname, versionclass):
@@ -23,14 +42,14 @@ def apply_concurrency_check(model, fieldname, versionclass):
     if hasattr(model, 'RevisionMetaInfo'):
         raise ImproperlyConfigured("%s is already under concurrency management" % model)
 
+    logger.debug('Applying concurrency check to %s' % model)
+
     ver = versionclass()
     ver.contribute_to_class(model, fieldname)
     model.RevisionMetaInfo.field = ver
 
     if not model.RevisionMetaInfo.versioned_save:
-        old_save = getattr(model, 'save')
-        setattr(model, 'save', _wrap_save(old_save))
-        model.RevisionMetaInfo.versioned_save = True
+        _wrap_model_save(model)
 
 
 def concurrency_check(model_instance, force_insert=False, force_update=False, using=None, **kwargs):

concurrency/core.py

@@ -1,21 +1,25 @@
-import warnings
-from functools import update_wrapper
+import logging
+from functools import update_wrapper, wraps
 from django.conf import settings
-from django.db import DatabaseError, connections, router
+from django.db import connections, router
 from django.utils.translation import ugettext as _
+
+logger = logging.getLogger('concurrency')
+
 from concurrency.exceptions import VersionChangedError, RecordModifiedError, InconsistencyError
+from concurrency.utils import deprecated
+
 
 __all__ = []
 
-def deprecate(target, subst, version):
-    warnings.warn("`{0}` will be removed in version `{2}`. Please use `{1}`".format(target, subst, version),
-                  category=DeprecationWarning)
 
+@deprecated('concurrency.api.apply_concurrency_check', '0.5')
 def apply_concurrency_check(model, fieldname, versionclass):
     from concurrency.api import apply_concurrency_check as acc
     return acc(model, fieldname, versionclass)
 
 
+@deprecated('concurrency.api.apply_concurrency_check', '0.5')
 def concurrency_check(model_instance, force_insert=False, force_update=False, using=None, **kwargs):
     from concurrency.api import concurrency_check as cc
     return cc(model_instance, force_insert, force_update, using, **kwargs)
@@ -36,6 +40,14 @@ def _select_lock(model_instance, version_value=None):
         raise InconsistencyError(_('Version field is set (%s) but record has not `pk`.' % value))
 
 
+def _wrap_model_save(model, force=False):
+    if force or not model.RevisionMetaInfo.versioned_save:
+        logger.debug('Wrapping save method of %s' % model)
+        old_save = getattr(model, 'save')
+        setattr(model, 'save', _wrap_save(old_save))
+        model.RevisionMetaInfo.versioned_save = True
+
+
 def _wrap_save(func):
     def inner(self, force_insert=False, force_update=False, using=None, **kwargs):
         concurrency_check(self, force_insert, force_update, using, **kwargs)
@@ -47,18 +59,11 @@ def inner(self, force_insert=False, force_update=False, using=None, **kwargs):
 def _versioned_save(self, force_insert=False, force_update=False, using=None):
     if force_insert and force_update:
         raise ValueError("Cannot force both insert and updating in model saving.")
-    concurrency_check(self, force_insert, force_update, using)
+    if not force_insert:
+        _select_lock(self)
     self.save_base(using=using, force_insert=force_insert, force_update=force_update)
 
 
-def class_prepared_concurrency_handler(sender, **kwargs):
-    if hasattr(sender, 'RevisionMetaInfo') and not (sender.RevisionMetaInfo.manually or
-                                                    sender.RevisionMetaInfo.versioned_save):
-        old_save = getattr(sender, 'save')
-        setattr(sender, 'save', _wrap_save(old_save))
-        sender.RevisionMetaInfo.versioned_save = True
-
-
 class RevisionMetaInfo:
     field = None
     versioned_save = False

concurrency/forms.py

@@ -20,7 +20,7 @@ def clean(self):
         try:
             _select_lock(self.instance, self.cleaned_data[self.instance.RevisionMetaInfo.field.name])
         except RecordModifiedError:
-            self._update_errors({NON_FIELD_ERRORS: self.error_class([_('Record modified')])})
+            self._update_errors({NON_FIELD_ERRORS: self.error_class([_('Record Modified')])})
 
         return super(ConcurrentForm, self).clean()
 

concurrency/models.py

@@ -1,5 +1,17 @@
+import logging
 from django.db.models.signals import class_prepared
-from concurrency.core import class_prepared_concurrency_handler
+from concurrency.core import _wrap_model_save
+
+logger = logging.getLogger('concurrency')
+
+__all__ = []
+
+
+def class_prepared_concurrency_handler(sender, **kwargs):
+    if hasattr(sender, 'RevisionMetaInfo') and not (sender.RevisionMetaInfo.manually):
+        _wrap_model_save(sender)
+    else:
+        logger.debug('Skipped concurrency for %s' % sender)
 
 
 class_prepared.connect(class_prepared_concurrency_handler, dispatch_uid='class_prepared_concurrency_handler')

concurrency/tests/__init__.py

@@ -3,8 +3,11 @@
 from concurrency.tests.forms import *
 from concurrency.tests.middleware import *
 from concurrency.tests.conf import *
+from concurrency.tests.api import * #NOQA
 
 try:
     from concurrency.tests.south_test import *
 except ImportError:
     pass
+
+

concurrency/tests/all.py

@@ -21,7 +21,6 @@
 
 
 logger = logging.getLogger('concurrency.tests')
-logger.setLevel(logging.DEBUG)
 
 
 class ConcurrencyTest0(ConcurrencyTestMixin, TestCase):

concurrency/tests/api.py

@@ -0,0 +1,18 @@
+from django.test import TestCase
+from concurrency.api import is_changed, get_revision_of_object
+from concurrency.tests import TestModel0
+
+
+class ConcurrencyTestApi(TestCase):
+
+    def test_is_changed(self):
+        o1 = TestModel0.objects.create()
+        o2 = TestModel0.objects.get(pk=o1.pk)
+        self.assertFalse(is_changed(o1))
+        o1.save()
+        self.assertTrue(is_changed(o2))
+
+    def test_get_revision_of_object(self):
+        o1 = TestModel0.objects.create()
+        self.assertEqual(get_revision_of_object(o1), o1.version)
+

concurrency/tests/models.py

@@ -1,8 +1,11 @@
 from django.contrib.auth.models import User, Group
 from django.db import models
 from django.db.models.base import ModelBase
-from concurrency.core import concurrency_check
+from concurrency.core import concurrency_check, _wrap_model_save
 from concurrency.fields import IntegerVersionField, AutoIncVersionField
+import logging
+
+logger = logging.getLogger('concurrency.test')
 
 
 class AbstractConcurrentModel(models.Model):
@@ -185,3 +188,9 @@ class TestIssue3Model(models.Model):
     class Meta:
         app_label = 'concurrency'
 
+
+# TODO: investigate why tox requires this. (Maybe depends on the order of the calls of the ``class_prepared`` ?
+for model in [TestAbstractModel0, TestModel0, ModelWithCustomSave, TestIssue3Model, AutoIncConcurrentModel,
+              TestModelWithCustomSave]:
+    _wrap_model_save(model, True)
+