start creating a low leve API

src/concurrency/admin.py

@@ -90,7 +90,7 @@ def response_action(self, request, queryset):  # noqa
             else:
                 selected = request.POST.getlist(helpers.ACTION_CHECKBOX_NAME)
 
-            revision_field = self.model._concurrencymeta._field
+            revision_field = self.model._concurrencymeta.field
             if not selected:
                 return None
 

src/concurrency/api.py

@@ -60,7 +60,7 @@ def apply_concurrency_check(model, fieldname, versionclass):
     ver = versionclass()
 
     ver.contribute_to_class(model, fieldname)
-    model._concurrencymeta._field = ver
+    model._concurrencymeta.field = ver
 
     from concurrency.fields import class_prepared_concurrency_handler
 

src/concurrency/core.py

@@ -20,7 +20,7 @@ def emit(self, record):
 
 
 def get_version_fieldname(obj):
-    return obj._concurrencymeta._field.attname
+    return obj._concurrencymeta.field.attname
 
 
 def _set_version(obj, version):
@@ -30,14 +30,14 @@ def _set_version(obj, version):
     This function should be used with 'raw' values, any type conversion should be managed in
     VersionField._set_version_value(). This is needed for future enhancement of concurrency.
     """
-    obj._concurrencymeta._field._set_version_value(obj, version)
+    obj._concurrencymeta.field._set_version_value(obj, version)
 
 
 def _select_lock(model_instance, version_value=None):
     if (not conf.ENABLED):
         return
 
-    version_field = model_instance._concurrencymeta._field
+    version_field = model_instance._concurrencymeta.field
     value = version_value or getattr(model_instance, version_field.name)
     is_versioned = value != version_field.get_default()
 
@@ -52,7 +52,7 @@ def _select_lock(model_instance, version_value=None):
 
 
 class ConcurrencyOptions:
-    _field = None
+    field = None
     versioned_save = False
     manually = False
     enabled = True

src/concurrency/fields.py

@@ -35,7 +35,7 @@ def class_prepared_concurrency_handler(sender, **kwargs):
             sender._concurrencymeta.enabled = getattr(sender.ConcurrencyMeta, 'enabled')
 
         if not (sender._concurrencymeta.manually):
-            sender._concurrencymeta._field.wrap_model(sender)
+            sender._concurrencymeta.field.wrap_model(sender)
 
         setattr(sender, 'get_concurrency_version', get_revision_of_object)
 
@@ -97,7 +97,7 @@ def contribute_to_class(self, cls, name, virtual_only=False):
         if hasattr(cls, '_concurrencymeta') or cls._meta.abstract:
             return
         setattr(cls, '_concurrencymeta', ConcurrencyOptions())
-        cls._concurrencymeta._field = self
+        cls._concurrencymeta.field = self
         cls._concurrencymeta.base = cls
 
     def _set_version_value(self, model_instance, value):
@@ -119,12 +119,12 @@ def wrap_model(cls, model, force=False):
     @staticmethod
     def _wrap_model_methods(model):
         old_do_update = getattr(model, '_do_update')
-        setattr(model, '_do_update', model._concurrencymeta._field._wrap_do_update(old_do_update))
+        setattr(model, '_do_update', model._concurrencymeta.field._wrap_do_update(old_do_update))
 
     def _wrap_do_update(self, func):
 
         def _do_update(model_instance, base_qs, using, pk_val, values, update_fields, forced_update):
-            version_field = model_instance._concurrencymeta._field
+            version_field = model_instance._concurrencymeta.field
             old_version = get_revision_of_object(model_instance)
 
             if not version_field.model._meta.abstract:
@@ -236,13 +236,13 @@ def pre_save(self, model_instance, add):
     @staticmethod
     def _increment_version_number(obj):
         old_value = get_revision_of_object(obj)
-        setattr(obj, obj._concurrencymeta._field.attname, int(old_value) + 1)
+        setattr(obj, obj._concurrencymeta.field.attname, int(old_value) + 1)
 
     @staticmethod
     def _wrap_model_methods(model):
         super(TriggerVersionField, TriggerVersionField)._wrap_model_methods(model)
         old_save = getattr(model, 'save')
-        setattr(model, 'save', model._concurrencymeta._field._wrap_save(old_save))
+        setattr(model, 'save', model._concurrencymeta.field._wrap_save(old_save))
 
     @staticmethod
     def _wrap_save(func):
@@ -253,7 +253,7 @@ def inner(self, force_insert=False, force_update=False, using=None, **kwargs):
             if reload:
                 ret = refetch(self)
                 setattr(self,
-                        self._concurrencymeta._field.attname,
+                        self._concurrencymeta.field.attname,
                         get_revision_of_object(ret))
             return ret
         return update_wrapper(inner, func)

src/concurrency/forms.py

@@ -24,7 +24,7 @@ class ConcurrentForm(ModelForm):
     def clean(self):
         try:
             if self.instance.pk:
-                _select_lock(self.instance, self.cleaned_data[self.instance._concurrencymeta._field.name])
+                _select_lock(self.instance, self.cleaned_data[self.instance._concurrencymeta.field.name])
 
         except RecordModifiedError:
                 self._update_errors(ValidationError({NON_FIELD_ERRORS: self.error_class([_('Record Modified')])}))

src/concurrency/utils.py

@@ -105,8 +105,8 @@ def test_concurrency_management(self):
         target = self.concurrency_model
         self.assertTrue(hasattr(target, '_concurrencymeta'),
                         "%s is not under concurrency management" % self.concurrency_model)
-        info = getattr(target, '_concurrencymeta', None)
-        revision_field = info._field
+
+        revision_field = target._concurrencymeta.field
 
         self.assertTrue(revision_field in target._meta.fields,
                         "%s: version field not in meta.fields" % self.concurrency_model)