- new modules api. see CHANGES

- new module exceptions,see CHANGES

Author: saxix

CHANGES

@@ -1,6 +1,10 @@
 Release 0.4.0 (under development)
 =================================
 
+* start deprecation of ``concurrency.core.VersionChangedError``, ``concurrency.core.RecordModifiedError``,
+``concurrency.core.InconsistencyError``,moved in ``concurrency.exceptions``
+* start deprecation of ``concurrency.core.apply_concurrency_check``, ``concurrency.core.concurrency_check
+    moved in ``concurrency.api``
 * added :ref:`CONCURRECY_SANITY_CHECK` settings entry
 * signing of version number to avoid tampering (:ref:`concurrentform`)
 * added :ref:`ConcurrencyTestMixin` to help test on concurrency managed models

concurrency/api.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+from django.core.exceptions import ImproperlyConfigured
+
+from django.utils.translation import gettext as _
+from concurrency.core import _wrap_save, _select_lock
+
+__all__ = ['apply_concurrency_check', 'concurrency_check']
+
+
+def apply_concurrency_check(model, fieldname, versionclass):
+    """
+    Apply concurrency management to existing Models.
+
+    :param model: Model class to update
+    :type model: django.db.Model
+
+    :param fieldname: name of the field
+    :type fieldname: basestring
+
+    :param versionclass:
+    :type versionclass: concurrency.fields.VersionField subclass
+    """
+    if hasattr(model, 'RevisionMetaInfo'):
+        raise ImproperlyConfigured("%s is already under concurrency management" % 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
+
+
+def concurrency_check(model_instance, force_insert=False, force_update=False, using=None, **kwargs):
+    if not force_insert:
+        _select_lock(model_instance)

concurrency/core.py

@@ -1,55 +1,24 @@
+import warnings
 from functools import update_wrapper
 from django.conf import settings
-from django.core.exceptions import ImproperlyConfigured, ValidationError
 from django.db import DatabaseError, connections, router
 from django.utils.translation import ugettext as _
+from concurrency.exceptions import VersionChangedError, RecordModifiedError, InconsistencyError
 
 __all__ = []
 
-
-class VersionChangedError(ValidationError):
-    pass
-
-
-class RecordModifiedError(DatabaseError):
-    def __init__(self, *args, **kwargs):
-        self.target = kwargs.pop('target')
-        super(RecordModifiedError, self).__init__(*args, **kwargs)
-
-
-class InconsistencyError(DatabaseError):
-    pass
-
+def deprecate(target, subst, version):
+    warnings.warn("`{0}` will be removed in version `{2}`. Please use `{1}`".format(target, subst, version),
+                  category=DeprecationWarning)
 
 def apply_concurrency_check(model, fieldname, versionclass):
-    """
-    Apply concurrency management to existing Models.
-
-    :param model: Model class to update
-    :type model: django.db.Model
-
-    :param fieldname: name of the field
-    :type fieldname: basestring
-
-    :param versionclass:
-    :type versionclass: concurrency.fields.VersionField subclass
-    """
-    if hasattr(model, 'RevisionMetaInfo'):
-        raise ImproperlyConfigured("%s is already under concurrency management" % 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
+    from concurrency.api import apply_concurrency_check as acc
+    return acc(model, fieldname, versionclass)
 
 
 def concurrency_check(model_instance, force_insert=False, force_update=False, using=None, **kwargs):
-    if not force_insert:
-        _select_lock(model_instance)
+    from concurrency.api import concurrency_check as cc
+    return cc(model_instance, force_insert, force_update, using, **kwargs)
 
 
 def _select_lock(model_instance, version_value=None):

concurrency/exceptions.py

@@ -0,0 +1,16 @@
+from django.core.exceptions import ImproperlyConfigured, ValidationError
+from django.db import DatabaseError
+
+
+class VersionChangedError(ValidationError):
+    pass
+
+
+class RecordModifiedError(DatabaseError):
+    def __init__(self, *args, **kwargs):
+        self.target = kwargs.pop('target')
+        super(RecordModifiedError, self).__init__(*args, **kwargs)
+
+
+class InconsistencyError(DatabaseError):
+    pass