Add alters_data attribute to all model functions that alter data

oscar/apps/basket/abstract_models.py

             line.quantity += quantity
             line.save()
         self._lines = None
+    add_product.alters_data = True
 
     def get_discounts(self):
         if self.discounts is None:
                                              line.quantity)
             existing_line.save()
             line.delete()
+    merge_line.alters_data = True
 
     def merge(self, basket, add_quantities=True):
         """
         basket.date_merged = now()
         basket.save()
         self._lines = None
+    merge.alters_data = True
 
     def freeze(self):
         """
         """
         self.status = self.FROZEN
         self.save()
+    freeze.alters_data = True
 
     def thaw(self):
         """
         """
         self.status = self.OPEN
         self.save()
+    thaw.alters_data = True
 
     def set_as_submitted(self):
         """Mark this basket as submitted."""
         self.status = self.SUBMITTED
         self.date_submitted = now()
         self.save()
+    set_as_submitted.alters_data = True
 
     def set_as_tax_exempt(self):
         self.exempt_from_tax = True

oscar/apps/catalogue/abstract_models.py

         from oscar.apps.catalogue.categories import create_from_breadcrumbs
         category = create_from_breadcrumbs(breadcrumb)
 
-        temp = get_model('catalogue', 'ProductCategory')(category=category, product=self)
+        temp = get_model('catalogue', 'ProductCategory')(
+            category=category, product=self)
         temp.save()
+    add_category_from_breadcrumbs.alters_data = True
 
     def attribute_summary(self):
         u"""Return a string of all of a product's attributes"""

oscar/apps/customer/abstract_models.py

     def archive(self):
         self.location = self.ARCHIVE
         self.save()
+    archive.alters_data = True
 
     @property
     def is_read(self):
         self.status = self.ACTIVE
         self.date_confirmed = now()
         self.save()
+    confirm.alters_data = True
 
     def cancel(self):
         self.status = self.CANCELLED
         self.date_cancelled = now()
         self.save()
+    cancel.alters_data = True
 
     def close(self):
         self.status = self.CLOSED
         self.date_closed = now()
         self.save()
+    close.alters_data = True
 
     def get_email_address(self):
         if self.user:

oscar/apps/offer/models.py

         self.num_orders += 1
         self.total_discount += discount
         self.save()
+    record_usage.alters_data = True
 
 
 class Condition(models.Model):

oscar/apps/order/abstract_models.py

                 line.status = self.cascade[self.status]
                 line.save()
         self.save()
+    set_status.alters_data = True
 
     @property
     def is_anonymous(self):
                                     'new_status': new_status, 'status': self.status})
         self.status = new_status
         self.save()
+    set_status.alters_data = True
 
     @property
     def category(self):

oscar/apps/partner/abstract_models.py

             self.num_allocated = 0
         self.num_allocated += quantity
         self.save()
+    allocate.alters_data = True
 
     def is_allocation_consumption_possible(self, quantity):
         return quantity <= min(self.num_allocated, self.num_in_stock)
         self.num_allocated -= quantity
         self.num_in_stock -= quantity
         self.save()
+    consume_allocation.alters_data = True
 
     def cancel_allocation(self, quantity):
         # We ignore requests that request a cancellation of more than the amount already
         # allocated.
         self.num_allocated -= min(self.num_allocated, quantity)
         self.save()
+    cancel_allocation.alters_data = True
 
     @property
     def net_stock_level(self):
         """
         self.price_excl_tax = price
         self.save()
+    set_discount_price.alters_data = True
 
     # Price retrieval methods - these default to no tax being applicable
     # These are intended to be overridden.
     def close(self):
         self.status = self.CLOSED
         self.save()
+    close.alters_data = True
 
     def __unicode__(self):
         return _('<stockalert for "%(stock)s" status %(status)s>') % {'stock': self.stockrecord, 'status': self.status}

oscar/apps/payment/models.py

 
 class Transaction(models.Model):
     """
-    A transaction for payment sources which need a secondary 'transaction' to actually take the money
+    A transaction for payment sources which need a secondary 'transaction' to
+    actually take the money
 
-    This applies mainly to credit card sources which can be a pre-auth for the money.  A 'complete'
-    needs to be run later to debit the money from the account.
+    This applies mainly to credit card sources which can be a pre-auth for the
+    money.  A 'complete' needs to be run later to debit the money from the
+    account.
     """
-    source = models.ForeignKey('payment.Source', related_name='transactions', verbose_name=_("Source"))
+    source = models.ForeignKey(
+        'payment.Source', related_name='transactions',
+        verbose_name=_("Source"))
 
     # We define some sample types
     AUTHORISE, DEBIT, REFUND = 'Authorise', 'Debit', 'Refund'
     date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     def __unicode__(self):
-        return _("%(type)s of %(amount).2f") % {'type': self.txn_type, 'amount': self.amount}
+        return _("%(type)s of %(amount).2f") % {
+            'type': self.txn_type, 'amount': self.amount}
 
     class Meta:
         verbose_name = _("Transaction")
     multiple sources such as cheque, credit accounts, gift cards.  Each payment
     source will have its own entry.
     """
-    order = models.ForeignKey('order.Order', related_name='sources', verbose_name=_("Order"))
-    source_type = models.ForeignKey('payment.SourceType', verbose_name=_("Source Type"))
-    currency = models.CharField(_("Currency"), max_length=12, default=settings.OSCAR_DEFAULT_CURRENCY)
+    order = models.ForeignKey('order.Order',
+                              related_name='sources', verbose_name=_("Order"))
+    source_type = models.ForeignKey('payment.SourceType',
+                                    verbose_name=_("Source Type"))
+    currency = models.CharField(_("Currency"), max_length=12,
+                                default=settings.OSCAR_DEFAULT_CURRENCY)
 
     # Track the various amounts associated with this source
-    amount_allocated = models.DecimalField(_("Amount Allocated"), decimal_places=2, max_digits=12, default=Decimal('0.00'))
-    amount_debited = models.DecimalField(_("Amount Debited"), decimal_places=2, max_digits=12, default=Decimal('0.00'))
-    amount_refunded = models.DecimalField(_("Amount Refunded"), decimal_places=2, max_digits=12, default=Decimal('0.00'))
-
-    # Reference number for this payment source.  This is often used to look up a
-    # transaction model for a particular payment partner.
-    reference = models.CharField(_("Reference"), max_length=128, blank=True, null=True)
+    amount_allocated = models.DecimalField(
+        _("Amount Allocated"), decimal_places=2, max_digits=12,
+        default=Decimal('0.00'))
+    amount_debited = models.DecimalField(
+        _("Amount Debited"), decimal_places=2, max_digits=12,
+        default=Decimal('0.00'))
+    amount_refunded = models.DecimalField(
+        _("Amount Refunded"), decimal_places=2, max_digits=12,
+        default=Decimal('0.00'))
+
+    # Reference number for this payment source.  This is often used to look up
+    # a transaction model for a particular payment partner.
+    reference = models.CharField(_("Reference"), max_length=128,
+                                 blank=True, null=True)
 
     # A customer-friendly label for the source, eg XXXX-XXXX-XXXX-1234
     label = models.CharField(_("Label"), max_length=128, blank=True, null=True)
                 self._create_transaction(*txn)
 
     def balance(self):
-        return self.amount_allocated - self.amount_debited + self.amount_refunded
+        return (self.amount_allocated - self.amount_debited +
+                self.amount_refunded)
 
-    def create_deferred_transaction(self, txn_type, amount, reference=None, status=None):
+    def create_deferred_transaction(self, txn_type, amount, reference=None,
+                                    status=None):
         """
         Register the data for a transaction that can't be created yet due to FK
-        constraints.  This happens at checkout where create an payment source and a
-        transaction but can't save them until the order model exists.
+        constraints.  This happens at checkout where create an payment source
+        and a transaction but can't save them until the order model exists.
         """
         if self.deferred_txns is None:
             self.deferred_txns = []
         self.deferred_txns.append((txn_type, amount, reference, status))
 
-    def _create_transaction(self, txn_type, amount, reference=None, status=None):
+    def _create_transaction(self, txn_type, amount, reference=None,
+                            status=None):
         Transaction.objects.create(source=self,
                                    txn_type=txn_type,
                                    amount=amount,
         """
         self.amount_allocated += amount
         self.save()
-        self._create_transaction(Transaction.AUTHORISE, amount, reference, status)
+        self._create_transaction(
+            Transaction.AUTHORISE, amount, reference, status)
+    allocate.alters_data = True
 
     def debit(self, amount=None, reference=None, status=None):
         """
         self.amount_debited += amount
         self.save()
         self._create_transaction(Transaction.DEBIT, amount, reference, status)
+    debit.alters_data = True
 
     def refund(self, amount, reference=None, status=None):
         """
         self.amount_refunded += amount
         self.save()
         self._create_transaction(Transaction.REFUND, amount, reference, status)
+    refund.alters_data = True
 
     @property
     def amount_available_for_refund(self):
     or an internal source such as a managed account.i
     """
     name = models.CharField(_("Name"), max_length=128)
-    code = models.SlugField(_("Code"), max_length=128, help_text=_("""This is used within
-        forms to identify this source type"""))
+    code = models.SlugField(_("Code"), max_length=128,
+       help_text=_("This is used within forms to identify this source type"))
 
     class Meta:
         verbose_name = _("Source Type")
 
 
 class Bankcard(models.Model):
-    user = models.ForeignKey('auth.User', related_name='bankcards', verbose_name=_("User"))
+    user = models.ForeignKey('auth.User', related_name='bankcards',
+                             verbose_name=_("User"))
     card_type = models.CharField(_("Card Type"), max_length=128)
     name = models.CharField(_("Name"), max_length=255)
     number = models.CharField(_("Number"), max_length=32)
     expiry_date = models.DateField(_("Expiry Date"))
 
     # For payment partners who are storing the full card details for us
-    partner_reference = models.CharField(_("Partner Reference"), max_length=255, null=True, blank=True)
+    partner_reference = models.CharField(
+        _("Partner Reference"), max_length=255, null=True, blank=True)
 
     class Meta:
         verbose_name = _("Bankcard")

oscar/apps/promotions/models.py

     def record_click(self):
         self.clicks += 1
         self.save()
+    record_click.alters_data = True
 
 
 class PagePromotion(LinkedPromotion):
 
 class Image(AbstractPromotion):
     """
-    An image promotion is simply a named image which has an optional 
+    An image promotion is simply a named image which has an optional
     link to another part of the site (or another site).
-    
+
     This can be used to model both banners and pods.
     """
     _type = 'Image'
 class MultiImage(AbstractPromotion):
     """
     A multi-image promotion is simply a collection of image promotions
-    that are rendered in a specific way.  This models things like 
+    that are rendered in a specific way.  This models things like
     rotating banners.
     """
     _type = 'Multi-image'

oscar/apps/shipping/models.py

     description = models.TextField(_("Description"), blank=True)
 
     # We allow shipping methods to be linked to a specific set of countries
-    countries = models.ManyToManyField('address.Country', null=True, blank=True, verbose_name=_("Countries"))
+    countries = models.ManyToManyField('address.Country', null=True,
+                                       blank=True, verbose_name=_("Countries"))
 
     _basket = None
 
         verbose_name = _("Shipping Method")
         verbose_name_plural = _("Shipping Methods")
 
-
     def save(self, *args, **kwargs):
         if not self.code:
             self.code = slugify(self.name)
 
     def __unicode__(self):
         return self.name
-    
+
     def set_basket(self, basket):
         self._basket = basket
 
 class OrderAndItemCharges(ShippingMethod):
     """
     Standard shipping method
-    
-    This method has two components: 
+
+    This method has two components:
     * a charge per order
     * a charge per item
-    
-    Many sites use shipping logic which fits into this system.  However, for more
-    complex shipping logic, a custom shipping method object will need to be provided
-    that subclasses ShippingMethod.
+
+    Many sites use shipping logic which fits into this system.  However, for
+    more complex shipping logic, a custom shipping method object will need to
+    be provided that subclasses ShippingMethod.
     """
-    price_per_order = models.DecimalField(_("Price per order"), decimal_places=2, max_digits=12, default=D('0.00'))
-    price_per_item = models.DecimalField(_("Price per item"), decimal_places=2, max_digits=12, default=D('0.00'))
-    
+    price_per_order = models.DecimalField(
+        _("Price per order"), decimal_places=2, max_digits=12,
+        default=D('0.00'))
+    price_per_item = models.DecimalField(
+        _("Price per item"), decimal_places=2, max_digits=12,
+        default=D('0.00'))
+
     # If basket value is above this threshold, then shipping is free
-    free_shipping_threshold = models.DecimalField(_("Free Shipping"), decimal_places=2, max_digits=12, blank=True, null=True)
-    
+    free_shipping_threshold = models.DecimalField(
+        _("Free Shipping"), decimal_places=2, max_digits=12, blank=True,
+        null=True)
+
     _basket = None
 
     class Meta:
 
     def set_basket(self, basket):
         self._basket = basket
-    
+
     def basket_charge_incl_tax(self):
         """
         Return basket total including tax
         if self.free_shipping_threshold != None and \
                 self._basket.total_incl_tax >= self.free_shipping_threshold:
             return D('0.00')
-        
+
         charge = self.price_per_order
         for line in self._basket.lines.all():
             charge += line.quantity * self.price_per_item
         return charge
-    
+
     def basket_charge_excl_tax(self):
         """
-        Return basket total excluding tax.  
-        
+        Return basket total excluding tax.
+
         Default implementation assumes shipping is tax free.
         """
         return self.basket_charge_incl_tax()
 
 
 class WeightBased(ShippingMethod):
-    upper_charge = models.DecimalField(_("Upper Charge"), decimal_places=2, max_digits=12, null=True,
-                                      help_text=_("""This is the charge when the
-                                       weight of the basket is greater than all
-                                      the weight bands"""))
+    upper_charge = models.DecimalField(
+        _("Upper Charge"), decimal_places=2, max_digits=12, null=True,
+        help_text=_("This is the charge when the weight of the basket "
+                    "is greater than all the weight bands"""))
 
     weight_attribute = 'weight'
-    default_weight = models.DecimalField(_("Default Weight"), decimal_places=2, max_digits=12, default=D('0.00'),
-                        help_text=_("""Default product weight in Kg when no
-                                        weight attribute is defined"""))
+    default_weight = models.DecimalField(
+        _("Default Weight"), decimal_places=2, max_digits=12,
+        default=D('0.00'),
+        help_text=_("Default product weight in Kg when no weight attribute "
+                    "is defined"))
 
     class Meta:
         verbose_name = _("Weight-based Shipping Method")
         verbose_name_plural = _("Weight-based Shipping Methods")
 
     def basket_charge_incl_tax(self):
-        weight = Scales(attribute_code=self.weight_attribute, default_weight=self.default_weight).weigh_basket(self._basket)
+        weight = Scales(attribute_code=self.weight_attribute,
+                        default_weight=self.default_weight).weigh_basket(
+                            self._basket)
         band = self.get_band_for_weight(weight)
         if not band:
             if self.bands.all().count() > 0 and self.upper_charge:
             else:
                 return D('0.00')
         return band.charge
-    
+
     def basket_charge_excl_tax(self):
         return self.basket_charge_incl_tax()
-        
+
     def get_band_for_weight(self, weight):
         """
         Return the weight band for a given weight
                                                 limit will be determine by the
                                                 other weight bands"""))
     charge = models.DecimalField(_("Charge"), decimal_places=2, max_digits=12)
-    
+
     @property
     def weight_from(self):
         lower_bands = self.method.bands.filter(
         if not lower_bands:
             return D('0.00')
         return lower_bands[0].upper_limit
-    
+
     @property
     def weight_to(self):
         return self.upper_limit
-    
+
     class Meta:
         ordering = ['upper_limit']
         verbose_name = _("Weight Band")

oscar/apps/voucher/abstract_models.py

             self.applications.create(voucher=self, order=order)
         self.num_orders += 1
         self.save()
+    record_usage.alters_data = True
 
     def record_discount(self, discount):
         """
         """
         self.total_discount += discount
         self.save()
+    record_discount.alters_data = True
 
     @property
     def benefit(self):