Pylint house-keeping

oscar/apps/voucher/abstract_models.py

     (c) Once per customer
     """
     name = models.CharField(_("Name"), max_length=128,
-        help_text=_("""This will be shown in the checkout and basket once the voucher is entered"""))
-    code = models.CharField(_("Code"), max_length=128, db_index=True, unique=True,
+        help_text=_("This will be shown in the checkout and basket "
+                    "once the voucher is entered"))
+    code = models.CharField(_("Code"), max_length=128,
+                            db_index=True, unique=True,
         help_text=_("""Case insensitive / No spaces allowed"""))
-    offers = models.ManyToManyField('offer.ConditionalOffer', related_name='vouchers', verbose_name=_("Offers"),
-                                    limit_choices_to={'offer_type': "Voucher"})
+    offers = models.ManyToManyField(
+        'offer.ConditionalOffer', related_name='vouchers',
+        verbose_name=_("Offers"), limit_choices_to={'offer_type': "Voucher"})
 
-    SINGLE_USE, MULTI_USE, ONCE_PER_CUSTOMER = ('Single use', 'Multi-use', 'Once per customer')
+    SINGLE_USE, MULTI_USE, ONCE_PER_CUSTOMER = (
+        'Single use', 'Multi-use', 'Once per customer')
     USAGE_CHOICES = (
         (SINGLE_USE, _("Can be used once by one customer")),
         (MULTI_USE, _("Can be used multiple times by multiple customers")),
         (ONCE_PER_CUSTOMER, _("Can only be used once per customer")),
     )
-    usage = models.CharField(_("Usage"), max_length=128, choices=USAGE_CHOICES, default=MULTI_USE)
+    usage = models.CharField(_("Usage"), max_length=128,
+                             choices=USAGE_CHOICES, default=MULTI_USE)
 
     start_date = models.DateField(_('Start Date'))
     end_date = models.DateField(_('End Date'))
 
     # Audit information
-    num_basket_additions = models.PositiveIntegerField(_("Times added to basket"), default=0)
+    num_basket_additions = models.PositiveIntegerField(
+        _("Times added to basket"), default=0)
     num_orders = models.PositiveIntegerField(_("Times on orders"), default=0)
-    total_discount = models.DecimalField(_("Total discount"), decimal_places=2, max_digits=12, default=Decimal('0.00'))
-    
+    total_discount = models.DecimalField(
+        _("Total discount"), decimal_places=2, max_digits=12,
+        default=Decimal('0.00'))
+
     date_created = models.DateField(auto_now_add=True)
 
     class Meta:
         return self.name
 
     def clean(self):
-        if self.start_date and self.end_date and self.start_date > self.end_date:
-            raise exceptions.ValidationError(_('End date should be later than start date'))
+        if (self.start_date and self.end_date and
+            self.start_date > self.end_date):
+            raise exceptions.ValidationError(
+                _('End date should be later than start date'))
 
     def save(self, *args, **kwargs):
         self.code = self.code.upper()
     def is_available_to_user(self, user=None):
         """
         Test whether this voucher is available to the passed user.
-        
-        Returns a tuple of a boolean for whether it is successulf, and a message
+
+        Returns a tuple of a boolean for whether it is successulf, and a
+        message
         """
         is_available, message = False, ''
         if self.usage == self.SINGLE_USE:
         elif self.usage == self.ONCE_PER_CUSTOMER:
             if not user.is_authenticated():
                 is_available = False
-                message = _("This voucher is only available to signed in users")
+                message = _(
+                    "This voucher is only available to signed in users")
             else:
-                is_available = self.applications.filter(voucher=self, user=user).count() == 0
+                is_available = self.applications.filter(
+                    voucher=self, user=user).count() == 0
                 if not is_available:
-                    message = _("You have already used this voucher in a previous order")
+                    message = _("You have already used this voucher in "
+                                "a previous order")
         return is_available, message
-    
+
     def record_usage(self, order, user):
         """
         Records a usage of this voucher in an order.
     @property
     def benefit(self):
         return self.offers.all()[0].benefit
-        
-        
+
+
 class AbstractVoucherApplication(models.Model):
     """
     For tracking how often a voucher has been used
     """
-    voucher = models.ForeignKey('voucher.Voucher', related_name="applications", verbose_name=_("Voucher"))
-
-    # It is possible for an anonymous user to apply a voucher so we need to allow
-    # the user to be nullable
-    user = models.ForeignKey('auth.User', blank=True, null=True, verbose_name=_("User"))
+    voucher = models.ForeignKey(
+        'voucher.Voucher', related_name="applications",
+        verbose_name=_("Voucher"))
+
+    # It is possible for an anonymous user to apply a voucher so we need to
+    # allow the user to be nullable
+    user = models.ForeignKey('auth.User', blank=True, null=True,
+                             verbose_name=_("User"))
     order = models.ForeignKey('order.Order', verbose_name=_("Order"))
     date_created = models.DateField(_("Date Creted"), auto_now_add=True)
 

oscar/apps/voucher/admin.py

 Voucher = get_model('voucher', 'Voucher')
 VoucherApplication = get_model('voucher', 'VoucherApplication')
 
-    
+
 class VoucherAdmin(admin.ModelAdmin):
-    list_display = ('name', 'code', 'usage', 'num_basket_additions', 'num_orders', 'total_discount')    
+    list_display = ('name', 'code', 'usage', 'num_basket_additions',
+                    'num_orders', 'total_discount')
     readonly_fields = ('num_basket_additions', 'num_orders', 'total_discount')
     fieldsets = (
         (None, {
-            'fields': ('name', 'code', 'usage', 'start_date', 'end_date')
-        }),
+            'fields': ('name', 'code', 'usage', 'start_date', 'end_date')}),
         ('Benefit', {
-            'fields': ('offers',)
-        }),
+            'fields': ('offers',)}),
         ('Usage', {
-            'fields': ('num_basket_additions', 'num_orders', 'total_discount')
-        }),
-        
+            'fields': ('num_basket_additions', 'num_orders',
+                       'total_discount')}),
     )
-    
+
 
 class VoucherApplicationAdmin(admin.ModelAdmin):
     list_display = ('voucher', 'user', 'order', 'date_created')
-    readonly_fields = ('voucher', 'user', 'order')        
+    readonly_fields = ('voucher', 'user', 'order')
 
 
 admin.site.register(Voucher, VoucherAdmin)

oscar/apps/voucher/models.py

-from oscar.apps.voucher.abstract_models import AbstractVoucher, AbstractVoucherApplication
+from oscar.apps.voucher.abstract_models import (
+    AbstractVoucher, AbstractVoucherApplication)
 
 
 class Voucher(AbstractVoucher):

oscar/apps/voucher/reports.py

 from oscar.core.loading import get_class
 
 ReportGenerator = get_class('dashboard.reports.reports', 'ReportGenerator')
-ReportCSVFormatter = get_class('dashboard.reports.reports', 'ReportCSVFormatter')
-ReportHTMLFormatter = get_class('dashboard.reports.reports', 'ReportHTMLFormatter')
+ReportCSVFormatter = get_class(
+    'dashboard.reports.reports', 'ReportCSVFormatter')
+ReportHTMLFormatter = get_class(
+    'dashboard.reports.reports', 'ReportHTMLFormatter')
 Voucher = get_model('voucher', 'Voucher')
 
 
 
     formatters = {
         'CSV_formatter': VoucherReportCSVFormatter,
-        'HTML_formatter': VoucherReportHTMLFormatter
-    }
+        'HTML_formatter': VoucherReportHTMLFormatter}
 
     def generate(self):
         vouchers = Voucher._default_manager.all()

oscar/test/__init__.py

         self.assertEqual(httplib.OK, response.status_code)
 
     def assertInContext(self, response, key):
-        self.assertTrue(key in response.context, "Context should contain a variable '%s'" % key)
+        self.assertTrue(key in response.context,
+                        "Context should contain a variable '%s'" % key)
 
 
 class WebTestCase(WebTest):

oscar/test/decorators.py

 def dataProvider(fn_data_provider):
     """
-    Data provider decorator, allows another callable to provide the data for the test.  
-    This is a nice feature from PHPUnit which is very useful.  Am sticking with the JUnit style
-    naming as unittest does this already.
-    
-    Implementation based on http://melp.nl/2011/02/phpunit-style-dataprovider-in-python-unit-test/#more-525
+    Data provider decorator, allows another callable to provide the data for
+    the test.  This is a nice feature from PHPUnit which is very useful.  Am
+    sticking with the JUnit style naming as unittest does this already.
+
+    Implementation based on
+    http://melp.nl/2011/02/phpunit-style-dataprovider-in-python-unit-test/#more-525
     """
     def test_decorator(test_method):
         def execute_test_method_with_each_data_set(self):
             for data in fn_data_provider():
-                if len(data) == 2 and isinstance(data[0], tuple) and isinstance(data[1], dict):
+                if (len(data) == 2 and isinstance(data[0], tuple) and
+                    isinstance(data[1], dict)):
                     # Both args and kwargs being provided
                     args, kwargs = data[:]
                 else:
                 except AssertionError, e:
                     self.fail("%s (Provided data: %s, %s)" % (e, args, kwargs))
         return execute_test_method_with_each_data_set
-    return test_decorator
+    return test_decorator

oscar/test/helpers.py

 Free = get_class('shipping.methods', 'Free')
 Voucher = get_class('voucher.models', 'Voucher')
 OrderCreator = get_class('order.utils', 'OrderCreator')
-OrderTotalCalculator = get_class('checkout.calculators', 'OrderTotalCalculator')
+OrderTotalCalculator = get_class('checkout.calculators',
+                                 'OrderTotalCalculator')
 Partner, StockRecord = get_classes('partner.models', ('Partner',
                                                       'StockRecord'))
 (ProductClass,
                                          'Condition', 'Benefit'))
 
 
-def create_product(price=None, title="Dummy title", product_class="Dummy item class",
+def create_product(price=None, title="Dummy title",
+                   product_class="Dummy item class",
         partner="Dummy partner", partner_sku=None, upc=None, num_in_stock=10,
         attributes=None, **kwargs):
     """
     Helper method for creating products that are used in tests.
     """
-    ic,_ = ProductClass._default_manager.get_or_create(name=product_class)
+    ic, __ = ProductClass._default_manager.get_or_create(name=product_class)
     item = Product._default_manager.create(title=title, product_class=ic,
                                            upc=upc, **kwargs)
     if price is not None or partner_sku or num_in_stock is not None:
         if price is None:
             price = D('10.00')
 
-        partner,_ = Partner._default_manager.get_or_create(name=partner)
+        partner, __ = Partner._default_manager.get_or_create(name=partner)
         StockRecord._default_manager.create(product=item, partner=partner,
                                             partner_sku=partner_sku,
-                                            price_excl_tax=price, num_in_stock=num_in_stock)
+                                            price_excl_tax=price,
+                                            num_in_stock=num_in_stock)
     if attributes:
         for key, value in attributes.items():
-            attr,_ = ProductAttribute.objects.get_or_create(name=key, code=key)
-            ProductAttributeValue.objects.create(product=item, attribute=attr, value=value)
+            attr, __ = ProductAttribute.objects.get_or_create(
+                name=key, code=key)
+            ProductAttributeValue.objects.create(
+                product=item, attribute=attr, value=value)
 
     return item
 
 
-def create_order(number=None, basket=None, user=None, shipping_address=None, shipping_method=None,
-        billing_address=None, total_incl_tax=None, total_excl_tax=None, **kwargs):
+def create_order(number=None, basket=None, user=None, shipping_address=None,
+                 shipping_method=None, billing_address=None,
+                 total_incl_tax=None, total_excl_tax=None, **kwargs):
     """
     Helper method for creating an order for testing
     """
     """
     Helper method for creating an offer
     """
-    range = Range.objects.create(name="All products range", includes_all_products=True)
+    range = Range.objects.create(name="All products range",
+                                 includes_all_products=True)
     condition = Condition.objects.create(range=range,
                                          type=Condition.COUNT,
                                          value=1)
         name='Dummy offer',
         offer_type='Site',
         condition=condition,
-        benefit=benefit
-    )
+        benefit=benefit)
     return offer
 
 
         name="Test voucher",
         code="test",
         start_date=datetime.date.today(),
-        end_date=datetime.date.today() + datetime.timedelta(days=12)
-    )
+        end_date=datetime.date.today() + datetime.timedelta(days=12))
     voucher.offers.add(create_offer())
     return voucher

oscar/views/generic.py

         if 'action' in self.request.POST:
             model = self.get_object()
             # The do_* method is required to do what it needs to with the model
-            # it is passed, and then to assign the HTTP response to self.response.
+            # it is passed, and then to assign the HTTP response to
+            # self.response.
             method_name = "do_%s" % self.request.POST['action'].lower()
             if hasattr(self, method_name):
                 getattr(self, method_name)(model)
         ids = map(int, ids)
         if not ids:
             messages.error(
-                self.request, _("You need to select some %ss") % self.get_checkbox_object_name())
+                self.request,
+                _("You need to select some %ss") % self.get_checkbox_object_name())
             return HttpResponseRedirect(self.get_error_url(request))
 
         objects = self.get_objects(ids)