missing translations, remove unicode from translation strings

oscar/apps/address/abstract_models.py

     name = models.CharField(_('Official name (CAPS)'), max_length=128)
     printable_name = models.CharField(_('Country name'), max_length=128)
     
-    is_highlighted = models.BooleanField(default=False, db_index=True)
-    is_shipping_country = models.BooleanField(default=False, db_index=True)
+    is_highlighted = models.BooleanField(_("Is Highlighted"), default=False, db_index=True)
+    is_shipping_country = models.BooleanField(_("Is Shipping Country"), default=False, db_index=True)
     
     class Meta:
         abstract = True
     users the ability to add/edit/delete from their address book without affecting
     orders already placed. 
     """
-    user = models.ForeignKey('auth.User', related_name='addresses')
+    user = models.ForeignKey('auth.User', related_name='addresses', verbose_name=_("User"))
     
     # Customers can set defaults
     is_default_for_shipping = models.BooleanField(_("Default shipping address?"), default=False)
     # We keep track of the number of times an address has been used
     # as a shipping address so we can show the most popular ones 
     # first at the checkout.
-    num_orders = models.PositiveIntegerField(default=0)
+    num_orders = models.PositiveIntegerField(_("Number of Orders"), default=0)
     
     # A hash is kept to try and avoid duplicate addresses being added
     # to the address book.
-    hash = models.CharField(max_length=255, db_index=True)
-    date_created = models.DateTimeField(auto_now_add=True)
+    hash = models.CharField(_("Address Hash"), max_length=255, db_index=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
     
     def generate_hash(self):
         """

oscar/apps/analytics/abstract_models.py

     products.
     """
     
-    product = models.OneToOneField('catalogue.Product')
+    product = models.OneToOneField('catalogue.Product', verbose_name=_("Product"))
     
     # Data used for generating a score
     num_views = models.PositiveIntegerField(_('Views'), default=0)
     A record of a user's activity.
     """
     
-    user = models.OneToOneField('auth.User')
+    user = models.OneToOneField('auth.User', verbose_name=_("User"))
     
     # Browsing stats
     num_product_views = models.PositiveIntegerField(_('Product Views'), default=0)
 
 class AbstractUserProductView(models.Model):
     
-    user = models.ForeignKey('auth.User')
-    product = models.ForeignKey('catalogue.Product')
-    date_created = models.DateTimeField(auto_now_add=True)
+    user = models.ForeignKey('auth.User', verbose_name=_("User"))
+    product = models.ForeignKey('catalogue.Product', verbose_name=_("Product"))
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
      
     class Meta:
         abstract = True
 
 class AbstractUserSearch(models.Model):
     
-    user = models.ForeignKey('auth.User')
+    user = models.ForeignKey('auth.User', verbose_name=_("User"))
     query = models.CharField(_("Search term"), max_length=255, db_index=True)
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
      
     class Meta:
         abstract = True

oscar/apps/basket/abstract_models.py

     Basket object
     """
     # Baskets can be anonymously owned (which are merged if the user signs in)
-    owner = models.ForeignKey('auth.User', related_name='baskets', null=True)
+    owner = models.ForeignKey('auth.User', related_name='baskets', null=True, verbose_name=_("Owner"))
     STATUS_CHOICES = (
         (OPEN, _("Open - currently active")),
         (MERGED, _("Merged - superceded by another basket")),
         (SUBMITTED, _("Submitted - has been ordered at the checkout")),
     )
     status = models.CharField(_("Status"), max_length=128, default=OPEN, choices=STATUS_CHOICES)
-    vouchers = models.ManyToManyField('voucher.Voucher', null=True)
+    vouchers = models.ManyToManyField('voucher.Voucher', null=True, verbose_name=_("Vouchers"))
 
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_merged = models.DateTimeField(null=True, blank=True)
-    date_submitted = models.DateTimeField(null=True, blank=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+    date_merged = models.DateTimeField(_("Date Merged"), null=True, blank=True)
+    date_submitted = models.DateTimeField(_("Date Submitted"), null=True, blank=True)
 
     class Meta:
         abstract = True
     """
     A line of a basket (product and a quantity)
     """
-    basket = models.ForeignKey('basket.Basket', related_name='lines')
+    basket = models.ForeignKey('basket.Basket', related_name='lines', verbose_name=_("Basket"))
 
     # This is to determine which products belong to the same line
     # We can't just use product.id as you can have customised products
     # which should be treated as separate lines.  Set as a
     # SlugField as it is included in the path for certain views.
-    line_reference = models.SlugField(max_length=128, db_index=True)
+    line_reference = models.SlugField(_("Line Reference"), max_length=128, db_index=True)
 
-    product = models.ForeignKey('catalogue.Product', related_name='basket_lines')
+    product = models.ForeignKey('catalogue.Product', related_name='basket_lines', verbose_name=_("Product"))
     quantity = models.PositiveIntegerField(_('Quantity'), default=1)
 
     # We store the unit price incl tax of the product when it is first added to
     price_incl_tax = models.DecimalField(_('Price incl. Tax'), decimal_places=2, max_digits=12,
                                          null=True)
     # Track date of first addition
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     # Instance variables used to persist discount information
     _discount = Decimal('0.00')
     """
     An attribute of a basket line
     """
-    line = models.ForeignKey('basket.Line', related_name='attributes')
-    option = models.ForeignKey('catalogue.Option')
+    line = models.ForeignKey('basket.Line', related_name='attributes', verbose_name=_("Line"))
+    option = models.ForeignKey('catalogue.Option', verbose_name=_("Option"))
     value = models.CharField(_("Value"), max_length=255)
 
     class Meta:

oscar/apps/catalogue/abstract_models.py

 
     Not necessarily equivalent to top-level categories but usually will be.
     """
-    name = models.CharField(_('name'), max_length=128)
-    slug = models.SlugField(_('slug'), max_length=128, unique=True)
+    name = models.CharField(_('Name'), max_length=128)
+    slug = models.SlugField(_('Slug'), max_length=128, unique=True)
 
     # Some product type don't require shipping (eg digital products) - we use
     # this field to take some shortcuts in the checkout.
     # These are the options (set by the user when they add to basket) for this
     # item class.  For instance, a product class of "SMS message" would always
     # require a message to be specified before it could be bought.
-    options = models.ManyToManyField('catalogue.Option', blank=True)
+    options = models.ManyToManyField('catalogue.Option', blank=True, verbose_name=_("Options"))
 
     class Meta:
         abstract = True
         ordering = ['name']
-        verbose_name = _("Product class")
-        verbose_name_plural = _("Product classes")
+        verbose_name = _("Product Class")
+        verbose_name_plural = _("Product Classes")
 
     def save(self, *args, **kwargs):
         if not self.slug:
 
     Uses django-treebeard.
     """
-    name = models.CharField(_('name'), max_length=255, db_index=True)
-    description = models.TextField(_('description'), blank=True, null=True)
-    image = models.ImageField(_('image'), upload_to='categories', blank=True, null=True)
-    slug = models.SlugField(_('slug'), max_length=1024, db_index=True, editable=False)
-    full_name = models.CharField(_('full name'), max_length=1024, db_index=True, editable=False)
+    name = models.CharField(_('Name'), max_length=255, db_index=True)
+    description = models.TextField(_('Description'), blank=True, null=True)
+    image = models.ImageField(_('Image'), upload_to='categories', blank=True, null=True)
+    slug = models.SlugField(_('Slug'), max_length=1024, db_index=True, editable=False)
+    full_name = models.CharField(_('Full Name'), max_length=1024, db_index=True, editable=False)
 
     _slug_separator = '/'
     _full_name_separator = ' > '
     """
     Joining model between products and categories.
     """
-    product = models.ForeignKey('catalogue.Product')
-    category = models.ForeignKey('catalogue.Category')
-    is_canonical = models.BooleanField(_('is cannonical'), default=False, db_index=True)
+    product = models.ForeignKey('catalogue.Product', verbose_name=_("Product"))
+    category = models.ForeignKey('catalogue.Category', verbose_name=_("Categry"))
+    is_canonical = models.BooleanField(_('Is Cannonical'), default=False, db_index=True)
 
     class Meta:
         abstract = True
         ordering = ['-is_canonical']
-        verbose_name = _('Product category')
-        verbose_name_plural = _('Product categories')
+        verbose_name = _('Product Category')
+        verbose_name_plural = _('Product Categories')
 
     def __unicode__(self):
         return u"<productcategory for product '%s'>" % self.product
     """
     A role that may be performed by a contributor to a product, eg Author, Actor, Director.
     """
-    name = models.CharField(_('name'), max_length=50)
-    name_plural = models.CharField(_('name plural'), max_length=50)
+    name = models.CharField(_('Name'), max_length=50)
+    name_plural = models.CharField(_('Name Plural'), max_length=50)
     slug = models.SlugField()
 
     def __unicode__(self):
 
 
 class AbstractProductContributor(models.Model):
-    product = models.ForeignKey('catalogue.Product')
-    contributor = models.ForeignKey('catalogue.Contributor')
-    role = models.ForeignKey('catalogue.ContributorRole', blank=True, null=True)
+    product = models.ForeignKey('catalogue.Product', verbose_name=_("Product"))
+    contributor = models.ForeignKey('catalogue.Contributor', verbose_name=_("Contributor"))
+    role = models.ForeignKey('catalogue.ContributorRole', blank=True, null=True, verbose_name=_("Contributor Role"))
 
     def __unicode__(self):
         return '%s <- %s - %s' % (self.product, self.role, self.contributor)
 
     class Meta:
         abstract = True
-        verbose_name = _('Product contributor')
-        verbose_name_plural = _('Product contributors')
+        verbose_name = _('Product Contributor')
+        verbose_name_plural = _('Product Contributors')
 
 
 class AbstractProduct(models.Model):
                      not specific to a particular supplier.  Eg an ISBN for a book."""))
 
     # No canonical product should have a stock record as they cannot be bought.
-    parent = models.ForeignKey('self', null=True, blank=True, related_name='variants',
+    parent = models.ForeignKey('self', null=True, blank=True, related_name='variants', verbose_name=_("Parent"),
         help_text=_("""Only choose a parent product if this is a 'variant' of a canonical catalogue.  For example
                      if this is a size 4 of a particular t-shirt.  Leave blank if this is a CANONICAL PRODUCT (ie
                      there is only one version of this product)."""))
 
     # Use this field to indicate if the product is inactive or awaiting approval
     status = models.CharField(_('Status'), max_length=128, blank=True, null=True, db_index=True)
-    product_class = models.ForeignKey('catalogue.ProductClass', verbose_name=_('product class'), null=True,
+    product_class = models.ForeignKey('catalogue.ProductClass', verbose_name=_('Product Class'), null=True,
         help_text=_("""Choose what type of product this is"""))
     attributes = models.ManyToManyField('catalogue.ProductAttribute', through='ProductAttributeValue',
-        help_text=_("""A product attribute is something that this product MUST have, such as a size, as specified by its class"""))
-    product_options = models.ManyToManyField('catalogue.Option', blank=True,
+        verbose_name=_("Attributes"), help_text=_("A product attribute is something that this product MUST have, "
+        "such as a size, as specified by its class"))
+    product_options = models.ManyToManyField('catalogue.Option', blank=True, verbose_name=_("Product Options"),
         help_text=_("""Options are values that can be associated with a item when it is added to
                      a customer's basket.  This could be something like a personalised message to be
                      printed on a T-shirt."""))
 
     related_products = models.ManyToManyField('catalogue.Product', related_name='relations', blank=True,
-        help_text=_("""Related items are things like different formats of the same book.  Grouping them together allows
-                     better linking betwen products on the site."""))
+        verbose_name=_("Related Products"), help_text=_("""Related items are things like different formats
+            of the same book.  Grouping them together allows better linking betwen products on the site."""))
 
     # Recommended products
-    recommended_products = models.ManyToManyField('catalogue.Product', through='ProductRecommendation', blank=True)
+    recommended_products = models.ManyToManyField('catalogue.Product', through='ProductRecommendation', blank=True,
+        verbose_name=_("Recommended Products"))
 
     # Product score
     score = models.FloatField(_('Score'), default=0.00, db_index=True)
 
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     # This field is used by Haystack to reindex search
-    date_updated = models.DateTimeField(auto_now=True, db_index=True)
+    date_updated = models.DateTimeField(_("Date Updated"), auto_now=True, db_index=True)
 
-    categories = models.ManyToManyField('catalogue.Category', through='ProductCategory')
+    categories = models.ManyToManyField('catalogue.Category', through='ProductCategory', verbose_name=_("Categories"))
 
-    is_discountable = models.BooleanField(default=True)
+    is_discountable = models.BooleanField(_("Is Discountable"), default=True)
 
     objects = models.Manager()
     browsable = BrowsableProductManager()
     """
     'Through' model for product recommendations
     """
-    primary = models.ForeignKey('catalogue.Product', related_name='primary_recommendations')
-    recommendation = models.ForeignKey('catalogue.Product')
+    primary = models.ForeignKey('catalogue.Product', related_name='primary_recommendations',
+        verbose_name=_("Primary Product"))
+    recommendation = models.ForeignKey('catalogue.Product', verbose_name=_("Recommended Product"))
     ranking = models.PositiveSmallIntegerField(_('Ranking'), default=0)
 
     class Meta:
-        verbose_name = _('Product recommendation')
-        verbose_name_plural = _('Product recomendations')
+        verbose_name = _('Product Recommendation')
+        verbose_name_plural = _('Product Recomendations')
 
 
 class ProductAttributesContainer(object):
             self.initialised = True
             if result:
                 return result
-        raise AttributeError((_(u"%(obj)s has no attribute named " \
-                                u"'%(attr)s'") % \
+        raise AttributeError((_("%(obj)s has no attribute named " \
+                                "'%(attr)s'") % \
                               {'obj': self.product.product_class, 'attr': name}))
 
     def validate_attributes(self):
             value = getattr(self, attribute.code, None)
             if value is None:
                 if attribute.required:
-                    raise ValidationError(_(u"%(attr)s attribute cannot " \
-                                            u"be blank") % \
+                    raise ValidationError(_("%(attr)s attribute cannot " \
+                                            "be blank") % \
                                             {'attr': attribute.code})
             else:
                 try:
                     attribute.validate_value(value)
                 except ValidationError, e:
-                    raise ValidationError(_(u"%(attr)s attribute %(err)s") % \
+                    raise ValidationError(_("%(attr)s attribute %(err)s") % \
                                             {'attr': attribute.code,
                                              'err': e})
 
     """
     Defines an attribute for a product class. (For example, number_of_pages for a 'book' class)
     """
-    product_class = models.ForeignKey('catalogue.ProductClass', related_name='attributes', blank=True, null=True)
-    name = models.CharField(_('name'), max_length=128)
-    code = models.SlugField(_('code'), max_length=128, validators=[RegexValidator(regex=r'^[a-zA-Z_][0-9a-zA-Z_]*$',
+    product_class = models.ForeignKey('catalogue.ProductClass', related_name='attributes', blank=True, null=True,
+        verbose_name=_("Product Class"))
+    name = models.CharField(_('Name'), max_length=128)
+    code = models.SlugField(_('Code'), max_length=128, validators=[RegexValidator(regex=r'^[a-zA-Z_][0-9a-zA-Z_]*$',
         message=_("Code must match ^[a-zA-Z_][0-9a-zA-Z_]*$"))])
-    type = models.CharField(choices=TYPE_CHOICES, default=TYPE_CHOICES[0][0], max_length=20)
+    type = models.CharField(choices=TYPE_CHOICES, default=TYPE_CHOICES[0][0], max_length=20, verbose_name=_("Type"))
     option_group = models.ForeignKey('catalogue.AttributeOptionGroup', blank=True, null=True,
-        help_text=_('Select an option group if using type "Option"'))
+        verbose_name=_("Option Group"), help_text=_('Select an option group if using type "Option"'))
     entity_type = models.ForeignKey('catalogue.AttributeEntityType', blank=True, null=True,
-        help_text=_('Select an entity type if using type "Entity"'))
-    required = models.BooleanField(_('required'), default=False)
+        verbose_name=_("Entity Type"), help_text=_('Select an entity type if using type "Entity"'))
+    required = models.BooleanField(_('Required'), default=False)
 
     class Meta:
         abstract = True
         ordering = ['code']
-        verbose_name = _('Product attribute')
-        verbose_name_plural = _('Product attributes')
+        verbose_name = _('Product Attribute')
+        verbose_name_plural = _('Product Attributes')
 
     def _validate_text(self, value):
         if not (type(value) == unicode or type(value) == str):
-            raise ValidationError(_(u"Must be str or unicode"))
+            raise ValidationError(_("Must be str or unicode"))
 
     def _validate_float(self, value):
         try:
             float(value)
         except ValueError:
-            raise ValidationError(_(u"Must be a float"))
+            raise ValidationError(_("Must be a float"))
 
     def _validate_int(self, value):
         try:
             int(value)
         except ValueError:
-            raise ValidationError(_(u"Must be an integer"))
+            raise ValidationError(_("Must be an integer"))
 
     def _validate_date(self, value):
         if not (isinstance(value, datetime) or isinstance(value, date)):
-            raise ValidationError(_(u"Must be a date or datetime"))
+            raise ValidationError(_("Must be a date or datetime"))
 
     def _validate_bool(self, value):
         if not type(value) == bool:
-            raise ValidationError(_(u"Must be a boolean"))
+            raise ValidationError(_("Must be a boolean"))
 
     def _validate_entity(self, value):
         if not isinstance(value, get_model('catalogue', 'AttributeEntity')):
-            raise ValidationError(_(u"Must be an AttributeEntity model object instance"))
+            raise ValidationError(_("Must be an AttributeEntity model object instance"))
         if not value.pk:
-            raise ValidationError(_(u"Model has not been saved yet"))
+            raise ValidationError(_("Model has not been saved yet"))
         if value.type != self.entity_type:
-            raise ValidationError(_(u"Entity must be of type %s" % self.entity_type.name))
+            raise ValidationError(_("Entity must be of type %s" % self.entity_type.name))
 
     def _validate_option(self, value):
         if not isinstance(value, get_model('catalogue', 'AttributeOption')):
-            raise ValidationError(_(u"Must be an AttributeOption model object instance"))
+            raise ValidationError(_("Must be an AttributeOption model object instance"))
         if not value.pk:
-            raise ValidationError(_(u"AttributeOption has not been saved yet"))
+            raise ValidationError(_("AttributeOption has not been saved yet"))
         valid_values = self.option_group.options.values_list('option', flat=True)
         if value.option not in valid_values:
-            raise ValidationError(_(u"%(enum)s is not a valid choice "
-                                        u"for %(attr)s") % \
+            raise ValidationError(_("%(enum)s is not a valid choice "
+                                        "for %(attr)s") % \
                                        {'enum': value, 'attr': self})
 
     def get_validator(self):
 
     For example: number_of_pages = 295
     """
-    attribute = models.ForeignKey('catalogue.ProductAttribute')
-    product = models.ForeignKey('catalogue.Product', related_name='attribute_values')
-    value_text = models.CharField(_('text'), max_length=255, blank=True, null=True)
-    value_integer = models.IntegerField(_('integer'), blank=True, null=True)
-    value_boolean = models.BooleanField(_('boolean'), blank=True)
-    value_float = models.FloatField(_('float'), blank=True, null=True)
-    value_richtext = models.TextField(_('richtext'), blank=True, null=True)
-    value_date = models.DateField(_('date'), blank=True, null=True)
-    value_option = models.ForeignKey('catalogue.AttributeOption', blank=True, null=True)
-    value_entity = models.ForeignKey('catalogue.AttributeEntity', blank=True, null=True)
+    attribute = models.ForeignKey('catalogue.ProductAttribute', verbose_name=_("Attribute"))
+    product = models.ForeignKey('catalogue.Product', related_name='attribute_values', verbose_name=_("Product"))
+    value_text = models.CharField(_('Text'), max_length=255, blank=True, null=True)
+    value_integer = models.IntegerField(_('Integer'), blank=True, null=True)
+    value_boolean = models.BooleanField(_('Boolean'), blank=True)
+    value_float = models.FloatField(_('Float'), blank=True, null=True)
+    value_richtext = models.TextField(_('Richtext'), blank=True, null=True)
+    value_date = models.DateField(_('Date'), blank=True, null=True)
+    value_option = models.ForeignKey('catalogue.AttributeOption', blank=True, null=True,
+        verbose_name=_("Value Option"))
+    value_entity = models.ForeignKey('catalogue.AttributeEntity', blank=True, null=True,
+        verbose_name=_("Value Entity"))
 
     def _get_value(self):
         return getattr(self, 'value_%s' % self.attribute.type)
     attribute type
     For example, Language
     """
-    name = models.CharField(_('name'), max_length=128)
+    name = models.CharField(_('Name'), max_length=128)
 
     def __unicode__(self):
         return self.name
     Provides an option within an option group for an attribute type
     Examples: In a Language group, English, Greek, French
     """
-    group = models.ForeignKey('catalogue.AttributeOptionGroup', related_name='options')
-    option = models.CharField(_('option'), max_length=255)
+    group = models.ForeignKey('catalogue.AttributeOptionGroup', related_name='options', verbose_name=_("Group"))
+    option = models.CharField(_('Option'), max_length=255)
 
     def __unicode__(self):
         return self.option
 
     class Meta:
         abstract = True
-        verbose_name = _('Attribute option')
-        verbose_name_plural = _('Attribute options')
+        verbose_name = _('Attribute Option')
+        verbose_name_plural = _('Attribute Options')
 
 
 class AbstractAttributeEntity(models.Model):
     """
     name = models.CharField(_("Name"), max_length=255)
     slug = models.SlugField(_("Slug"), max_length=255, unique=False, blank=True)
-    type = models.ForeignKey('catalogue.AttributeEntityType', related_name='entities')
+    type = models.ForeignKey('catalogue.AttributeEntityType', related_name='entities', verbose_name=_("Type"))
 
     def __unicode__(self):
         return self.name
 
     class Meta:
         abstract = True
-        verbose_name = _('Attribute entity')
-        verbose_name_plural = _('Attribute entities')
+        verbose_name = _('Attribute Entity')
+        verbose_name_plural = _('Attribute Entities')
 
     def save(self, *args, **kwargs):
         if not self.slug:
     This is not the same as an attribute as options do not have a fixed value for
     a particular item - options, they need to be specified by the customer.
     """
-    name = models.CharField(_('name'), max_length=128)
-    code = models.SlugField(_('code'), max_length=128)
+    name = models.CharField(_("Name"), max_length=128)
+    code = models.SlugField(_("Code"), max_length=128)
 
     REQUIRED, OPTIONAL = ('Required', 'Optional')
     TYPE_CHOICES = (
 
     class Meta:
         abstract = True
-        verbose_name = _('Option')
-        verbose_name_plural = _('Options')
+        verbose_name = _("Option")
+        verbose_name_plural = _("Options")
 
     def __unicode__(self):
         return self.name
     """
     An image of a product
     """
-    product = models.ForeignKey('catalogue.Product', related_name='images')
+    product = models.ForeignKey('catalogue.Product', related_name='images', verbose_name=_("Product"))
     original = models.ImageField(_("Original"), upload_to=settings.OSCAR_IMAGE_FOLDER)
     caption = models.CharField(_("Caption"), max_length=200, blank=True, null=True)
 
     display_order = models.PositiveIntegerField(_("Display Order"), default=0,
         help_text=_("""An image with a display order of
                        zero will be the primary image for a product"""))
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     class Meta:
         abstract = True

oscar/apps/customer/abstract_models.py

     This is a record of all emails sent to a customer.
     Normally, we only record order-related emails.
     """
-    user = models.ForeignKey('auth.User', related_name='emails')
+    user = models.ForeignKey('auth.User', related_name='emails', verbose_name=_("User"))
     subject = models.TextField(_('Subject'), max_length=255)
-    body_text = models.TextField()
-    body_html = models.TextField(blank=True, null=True)
-    date_sent = models.DateTimeField(auto_now_add=True)
+    body_text = models.TextField(_("Body Text"))
+    body_html = models.TextField(_("Body HTML"), blank=True, null=True)
+    date_sent = models.DateTimeField(_("Date Sent"), auto_now_add=True)
 
     class Meta:
         abstract = True
         verbose_name_plural = _('Emails')
 
     def __unicode__(self):
-        return _(u"Email to %(user)s with subject '%(subject)s'") % {
+        return _("Email to %(user)s with subject '%(subject)s'") % {
             'user': self.user.username, 'subject': self.subject}
 
 
     # Template content for SMS messages
     sms_template = models.CharField(_('SMS Template'), max_length=170, blank=True, help_text=_("SMS template"))
 
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_updated = models.DateTimeField(auto_now=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+    date_updated = models.DateTimeField(_("Date Updated"), auto_now=True)
 
     objects = CommunicationTypeManager()
 

oscar/apps/dashboard/catalogue/views.py

 
     def get_context_data(self, **kwargs):
         ctx = super(CategoryCreateView, self).get_context_data(**kwargs)
-        ctx['title'] = "Add a new category"
+        ctx['title'] = _("Add a new category")
         return ctx
 
     def get_success_url(self):
-        messages.info(self.request, "Category created successfully")
+        messages.info(self.request, _("Category created successfully"))
         return super(CategoryCreateView, self).get_success_url()
 
 
 
     def get_context_data(self, **kwargs):
         ctx = super(CategoryUpdateView, self).get_context_data(**kwargs)
-        ctx['title'] = "Update category '%s'" % self.object.name
+        ctx['title'] = _("Update category '%s'") % self.object.name
         return ctx
 
     def get_success_url(self):
-        messages.info(self.request, "Category updated successfully")
+        messages.info(self.request, _("Category updated successfully"))
         return super(CategoryUpdateView, self).get_success_url()
 
 
         return ctx
 
     def get_success_url(self):
-        messages.info(self.request, "Category deleted successfully")
+        messages.info(self.request, _("Category deleted successfully"))
         return super(CategoryDeleteView, self).get_success_url()

oscar/apps/dashboard/offers/views.py

     context_object_name = 'offer'
 
     def get_success_url(self):
-        messages.success(self.request, "Offer deleted!")
+        messages.success(self.request, _("Offer deleted!"))
         return reverse('dashboard:offer-list')
 
 
     template_name = 'dashboard/offers/range_form.html'
 
     def get_success_url(self):
-        messages.success(self.request, "Range created")
+        messages.success(self.request, _("Range created"))
         return reverse('dashboard:range-list')
 
 
     template_name = 'dashboard/offers/range_form.html'
 
     def get_success_url(self):
-        messages.success(self.request, "Range updated")
+        messages.success(self.request, _("Range updated"))
         return reverse('dashboard:range-list')
 
 
     context_object_name = 'range'
 
     def get_success_url(self):
-        messages.warning(self.request, "Range deleted")
+        messages.warning(self.request, _("Range deleted"))
         return reverse('dashboard:range-list')
 
 

oscar/apps/dashboard/orders/views.py

         order_action = request.POST.get('order_action', '').lower()
         if order_action:
             if order_action not in self.order_actions:
-                messages.error(self.request, "Invalid action")
+                messages.error(self.request, _("Invalid action"))
                 return self.reload_page_response()
             else:
                 return getattr(self, order_action)(request, order)
     changes = get_changes_between_models(model1, model2, ['search_text'])
     change_descriptions = []
     for field, delta in changes.items():
-        change_descriptions.append(_(u"%(field)s changed from '%(old_value)s' to '%(new_value)s'") % {
+        change_descriptions.append(_("%(field)s changed from '%(old_value)s' to '%(new_value)s'") % {
             'field': field,
             'old_value': delta[0],
             'new_value': delta[1]})

oscar/apps/dashboard/pages/forms.py

     and *content* field. The specified URL will be validated and check if
     the same URL already exists in the system.
     """
-    url = forms.CharField(max_length=128, required=False,
+    url = forms.CharField(max_length=128, required=False, label=_("URL"),
                           help_text=_("Example: '/about/contact/'. Make sure"
                                       " to have leading and trailing slashes."))
 

oscar/apps/dashboard/pages/views.py

         Get context data with additional *title* and *page* objects attached.
         """
         ctx = super(PageUpdateView, self).get_context_data(**kwargs)
-        ctx['title'] = 'Update Page'
+        ctx['title'] = _('Update Page')
         return ctx
 
     def form_valid(self, form):

oscar/apps/dashboard/ranges/models.py

 import datetime
 import os
 import re
-
+from django.utils.translation import ugettext_lazy as _
 from django.db import models
+
+
 Product = models.get_model('catalogue', 'Product')
 
 
 class RangeProductFileUpload(models.Model):
-    range = models.ForeignKey('offer.Range', related_name='file_uploads')
-    filepath = models.CharField(max_length=255)
-    size = models.PositiveIntegerField()
-    uploaded_by = models.ForeignKey('auth.User')
-    date_uploaded = models.DateTimeField(auto_now_add=True)
+    range = models.ForeignKey('offer.Range', related_name='file_uploads', verbose_name=_("Range"))
+    filepath = models.CharField(_("File Path"), max_length=255)
+    size = models.PositiveIntegerField(_("Size"))
+    uploaded_by = models.ForeignKey('auth.User', verbose_name=_("Uploaded By"))
+    date_uploaded = models.DateTimeField(_("Date Uploaded"), auto_now_add=True)
 
     PENDING, FAILED, PROCESSED = 'Pending', 'Failed', 'Processed'
     choices = (
         (FAILED, FAILED),
         (PROCESSED, PROCESSED),
     )
-    status = models.CharField(max_length=32, choices=choices, default=PENDING)
-    error_message = models.CharField(max_length=255, null=True)
+    status = models.CharField(_("Status"), max_length=32, choices=choices, default=PENDING)
+    error_message = models.CharField(_("Error Message"), max_length=255, null=True)
 
     # Post-processing audit fields
-    date_processed = models.DateTimeField(null=True)
-    num_new_skus = models.PositiveIntegerField(null=True)
-    num_unknown_skus = models.PositiveIntegerField(null=True)
-    num_duplicate_skus = models.PositiveIntegerField(null=True)
+    date_processed = models.DateTimeField(_("Date Processed"), null=True)
+    num_new_skus = models.PositiveIntegerField(_("Number of New SKUs"), null=True)
+    num_unknown_skus = models.PositiveIntegerField(_("Number of Unknown SKUs"), null=True)
+    num_duplicate_skus = models.PositiveIntegerField(_("Number of Duplicate SKUs"), null=True)
 
     class Meta:
         ordering = ('-date_uploaded',)
+        verbose_name = _("Range Product Uploaded File")
+        verbose_name_plural = _("Range Product Uploaded Files")
 
     @property
     def filename(self):

oscar/apps/dashboard/ranges/views.py

 import os
-
 from django.views.generic import (ListView, DeleteView, CreateView, UpdateView)
-from django.utils.translation import ugettext_lazy as _
+from django.utils.translation import ungettext, ugettext_lazy as _
 from django.db.models.loading import get_model
 from django.core.urlresolvers import reverse
 from django.contrib import messages
 from django.shortcuts import get_object_or_404
 from django.http import HttpResponseRedirect
-from django.template.defaultfilters import pluralize
 from django.conf import settings
 
 from oscar.views.generic import BulkEditMixin
         if 'action' in self.request.POST:
             return reverse('dashboard:range-products', kwargs={'pk': self.object.id})
         else:
-            messages.success(self.request, "Range created")
+            messages.success(self.request, _("Range created"))
             return reverse('dashboard:range-list')
 
     def get_context_data(self, **kwargs):
         if 'action' in self.request.POST:
             return reverse('dashboard:range-products', kwargs={'pk': self.object.id})
         else:
-            messages.success(self.request, "Range updated")
+            messages.success(self.request, _("Range updated"))
             return reverse('dashboard:range-list')
 
     def get_context_data(self, **kwargs):
     context_object_name = 'range'
 
     def get_success_url(self):
-        messages.warning(self.request, "Range deleted")
+        messages.warning(self.request, _("Range deleted"))
         return reverse('dashboard:range-list')
 
 
         range = self.get_range()
         for product in products:
             range.included_products.remove(product)
-        messages.success(request, _('Removed %d products from range') %
-                         len(products))
+        num_products = len(products)
+        messages.success(request, ungettext("Removed %d product from range",
+                                            "Removed %d products from range",
+                                            num_products) % num_products)
         return HttpResponseRedirect(self.get_success_url(request))
 
     def add_products(self, request):
             range.included_products.add(product)
 
         num_products = len(products)
-        messages.success(request, _("Products added to range: %d") % (
-            num_products))
-
+        messages.success(request, ungettext("%d product added to range",
+                                            "%d products added to range",
+                                            num_products) % num_products)
         dupe_skus = form.get_duplicate_skus()
         if dupe_skus:
             messages.warning(
                 request,
-                _("The products with SKUs or UPCs matching %s are already in this range") % (", ".join(dupe_skus)))
+                _("The products with SKUs or UPCs matching %s are already in this range") % ", ".join(dupe_skus))
 
         missing_skus = form.get_missing_skus()
         if missing_skus:
             messages.warning(request,
-                             _("No product was found with SKU or UPC matching %s") % ', '.join(missing_skus))
+                             _("No product(s) were found with SKU or UPC matching %s") % ", ".join(missing_skus))
 
     def handle_file_products(self, request, range, form):
         if not 'file_upload' in request.FILES:

oscar/apps/dashboard/reports/forms.py

     type_choices = []
     for generator in generators:
         type_choices.append((generator.code, generator.description))
-    report_type = forms.ChoiceField(widget=forms.Select(), choices=type_choices,
+    report_type = forms.ChoiceField(widget=forms.Select(), choices=type_choices, label=_("Report Type"),
                                     help_text=_("Only the offer and order reports "
                                                 "use the selected date range"))
 

oscar/apps/dashboard/users/views.py

     actions = ('make_active', 'make_inactive', )
     current_view = 'dashboard:users-index'
     form_class = forms.UserSearchForm
-    desc_template = _(u'%(main_filter)s %(email_filter)s %(name_filter)s')
+    desc_template = _('%(main_filter)s %(email_filter)s %(name_filter)s')
     description = ''
 
     def get_queryset(self):

oscar/apps/dashboard/vouchers/forms.py

 
 
 class VoucherSearchForm(forms.Form):
-    name = forms.CharField(required=False)
-    code = forms.CharField(required=False)
-    is_active = forms.BooleanField(required=False)
+    name = forms.CharField(required=False, label=_("Name"))
+    code = forms.CharField(required=False, label=_("Code"))
+    is_active = forms.BooleanField(required=False, label=_("Is Active?"))
 
     def clean_code(self):
         return self.cleaned_data['code'].upper()

oscar/apps/dashboard/vouchers/views.py

         )
         name = form.cleaned_data['name']
         offer = ConditionalOffer.objects.create(
-            name="Offer for voucher '%s'" % name,
+            name=_("Offer for voucher '%s'") % name,
             offer_type="Voucher",
             benefit=benefit,
             condition=condition,

oscar/apps/offer/models.py

     """
     A conditional offer (eg buy 1, get 10% off)
     """
-    name = models.CharField(_('Name'), max_length=128, unique=True,
+    name = models.CharField(_("Name"), max_length=128, unique=True,
                             help_text=_("""This is displayed within the customer's
                             basket"""))
-    slug = models.SlugField(_('Slug'), max_length=128, unique=True, null=True)
-    description = models.TextField(_('Description'), blank=True, null=True)
+    slug = models.SlugField(_("Slug"), max_length=128, unique=True, null=True)
+    description = models.TextField(_("Description"), blank=True, null=True)
 
     # Offers come in a few different types:
     # (a) Offers that are available to all customers on the site.  Eg a
         (USER, _("User offer - available to certain types of user")),
         (SESSION, _("Session offer - temporary offer, available for a user for the duration of their session")),
     )
-    offer_type = models.CharField(_('Type'), choices=TYPE_CHOICES, default=SITE, max_length=128)
+    offer_type = models.CharField(_("Type"), choices=TYPE_CHOICES, default=SITE, max_length=128)
 
-    condition = models.ForeignKey('offer.Condition')
-    benefit = models.ForeignKey('offer.Benefit')
+    condition = models.ForeignKey('offer.Condition', verbose_name=_("Condition"))
+    benefit = models.ForeignKey('offer.Benefit', verbose_name=_("Benefit"))
 
     # Range of availability.  Note that if this is a voucher offer, then these
     # dates are ignored and only the dates from the voucher are used to determine
     # availability.
-    start_date = models.DateField(_('Start Date'), blank=True, null=True)
-    end_date = models.DateField(_('End Date'), blank=True, null=True,
-                                help_text=_("""Offers are not active on their end
-                                date, only the days preceding"""))
+    start_date = models.DateField(_("Start Date"), blank=True, null=True)
+    end_date = models.DateField(_("End Date"), blank=True, null=True,
+                                help_text=_("Offers are not active on their end "
+                                            "date, only the days preceding"))
 
     # Some complicated situations require offers to be applied in a set order.
-    priority = models.IntegerField(_('Priority'), default=0,
+    priority = models.IntegerField(_("Priority"), default=0,
         help_text=_("The highest priority offers are applied first"))
 
     # We track some information on usage
-    total_discount = models.DecimalField(_('Total Discount'), decimal_places=2, max_digits=12, default=Decimal('0.00'))
-    num_orders = models.PositiveIntegerField(_('Number of Orders'), default=0)
+    total_discount = models.DecimalField(_("Total Discount"), decimal_places=2, max_digits=12, default=Decimal('0.00'))
+    num_orders = models.PositiveIntegerField(_("Number of Orders"), default=0)
 
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+
+    redirect_url = ExtendedURLField(_("URL redirect (optional)"), blank=True)
 
     objects = models.Manager()
     active = ActiveOfferManager()
 
-    redirect_url = ExtendedURLField(_('URL redirect (optional)'), blank=True)
-
     # We need to track the voucher that this offer came from (if it is a voucher offer)
     _voucher = None
 
         (VALUE, _("Depends on value of items in basket that are in condition range")),
         (COVERAGE, _("Needs to contain a set number of DISTINCT items from the condition range"))
     )
-    range = models.ForeignKey('offer.Range')
+    range = models.ForeignKey('offer.Range', verbose_name=_("Range"))
     type = models.CharField(_('Type'), max_length=128, choices=TYPE_CHOICES)
     value = PositiveDecimalField(_('Value'), decimal_places=2, max_digits=12)
 
 class Benefit(models.Model):
     PERCENTAGE, FIXED, MULTIBUY, FIXED_PRICE = ("Percentage", "Absolute", "Multibuy", "Fixed price")
     TYPE_CHOICES = (
-        (PERCENTAGE, _("Discount is a % of the product's value")),
+        (PERCENTAGE, _("Discount is a %% of the product's value")),
         (FIXED, _("Discount is a fixed amount off the product's value")),
         (MULTIBUY, _("Discount is to give the cheapest product for free")),
         (FIXED_PRICE, _("Get the products that meet the condition for a fixed price")),
     )
-    range = models.ForeignKey('offer.Range', null=True, blank=True)
-    type = models.CharField(_('Type'), max_length=128, choices=TYPE_CHOICES)
-    value = PositiveDecimalField(_('Value'), decimal_places=2, max_digits=12,
+    range = models.ForeignKey('offer.Range', null=True, blank=True, verbose_name=_("Range"))
+    type = models.CharField(_("Type"), max_length=128, choices=TYPE_CHOICES)
+    value = PositiveDecimalField(_("Value"), decimal_places=2, max_digits=12,
                                  null=True, blank=True)
 
     price_field = 'price_incl_tax'
 
     # If this is not set, then there is no upper limit on how many products
     # can be discounted by this benefit.
-    max_affected_items = models.PositiveIntegerField(_('Max Affected Items'), blank=True, null=True,
-        help_text=_("""Set this to prevent the discount consuming all items within the range that are in the basket."""))
+    max_affected_items = models.PositiveIntegerField(_("Max Affected Items"), blank=True, null=True,
+        help_text=_("Set this to prevent the discount consuming all items within the range that are in the basket."))
 
     class Meta:
         verbose_name = _("Benefit")
     """
     name = models.CharField(_("Name"), max_length=128, unique=True)
     includes_all_products = models.BooleanField(_('Includes All Products'), default=False)
-    included_products = models.ManyToManyField('catalogue.Product', related_name='includes', blank=True)
-    excluded_products = models.ManyToManyField('catalogue.Product', related_name='excludes', blank=True)
-    classes = models.ManyToManyField('catalogue.ProductClass', related_name='classes', blank=True)
-    included_categories = models.ManyToManyField('catalogue.Category', related_name='includes', blank=True)
-    date_created = models.DateTimeField(auto_now_add=True)
+    included_products = models.ManyToManyField('catalogue.Product', related_name='includes', blank=True,
+        verbose_name=_("Included Products"))
+    excluded_products = models.ManyToManyField('catalogue.Product', related_name='excludes', blank=True,
+        verbose_name=_("Excluded Products"))
+    classes = models.ManyToManyField('catalogue.ProductClass', related_name='classes', blank=True,
+        verbose_name=_("Product Classes"))
+    included_categories = models.ManyToManyField('catalogue.Category', related_name='includes', blank=True,
+        verbose_name=_("Included Categories"))
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     __included_product_ids = None
     __excluded_product_ids = None

oscar/apps/order/abstract_models.py

     """
     number = models.CharField(_("Order number"), max_length=128, db_index=True)
     # We track the site that each order is placed within
-    site = models.ForeignKey('sites.Site')
-    basket_id = models.PositiveIntegerField(_('Basket ID'), null=True, blank=True)
+    site = models.ForeignKey('sites.Site', verbose_name=_("Site"))
+    basket_id = models.PositiveIntegerField(_("Basket ID"), null=True, blank=True)
     # Orders can be anonymous so we don't always have a customer ID
-    user = models.ForeignKey(User, related_name='orders', null=True, blank=True)
+    user = models.ForeignKey(User, related_name='orders', null=True, blank=True, verbose_name=_("User"))
     # Billing address is not always required (eg paying by gift card)
-    billing_address = models.ForeignKey('order.BillingAddress', null=True, blank=True)
+    billing_address = models.ForeignKey('order.BillingAddress', null=True, blank=True,
+        verbose_name=_("Billing Address"))
 
     # Total price looks like it could be calculated by adding up the
     # prices of the associated lines, but in some circumstances extra
 
     # Not all lines are actually shipped (such as downloads), hence shipping address
     # is not mandatory.
-    shipping_address = models.ForeignKey('order.ShippingAddress', null=True, blank=True)
+    shipping_address = models.ForeignKey('order.ShippingAddress', null=True, blank=True,
+        verbose_name=_("Shipping Address"))
     shipping_method = models.CharField(_("Shipping method"), max_length=128, null=True, blank=True)
 
     # Use this field to indicate that an order is on hold / awaiting payment
         if new_status == self.status:
             return
         if new_status not in self.available_statuses():
-            raise InvalidOrderStatus(_("'%(new_status)s' is not a valid status for order %(number)s "+
+            raise InvalidOrderStatus(_("'%(new_status)s' is not a valid status for order %(number)s "
                                        "(current status: '%(status)s')") % {
                                             'new_status': new_status,
                                             'number': self.number,
         abstract = True
         ordering = ['-date_placed',]
         permissions = (
-            ("can_view", "Can view orders (eg for reporting)"),
+            ("can_view", _("Can view orders (eg for reporting)")),
         )
         verbose_name = _("Order")
         verbose_name_plural = _("Orders")
     This are often used for audit purposes too.  IE, whenever an admin
     makes a change to an order, we create a note to record what happened.
     """
-    order = models.ForeignKey('order.Order', related_name="notes")
+    order = models.ForeignKey('order.Order', related_name="notes", verbose_name=_("Order"))
 
     # These are sometimes programatically generated so don't need a
     # user everytime
-    user = models.ForeignKey('auth.User', null=True)
+    user = models.ForeignKey('auth.User', null=True, verbose_name=_("User"))
 
     # We allow notes to be classified although this isn't always needed
     INFO, WARNING, ERROR, SYSTEM = 'Info', 'Warning', 'Error', 'System'
-    note_type = models.CharField(_('Note Type'), max_length=128, null=True)
+    note_type = models.CharField(_("Note Type"), max_length=128, null=True)
 
-    message = models.TextField(_('Message'))
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_updated = models.DateTimeField(auto_now=True)
+    message = models.TextField(_("Message"))
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+    date_updated = models.DateTimeField(_("Date Updated"), auto_now=True)
 
     # Notes can only be edited for 5 minutes after being created
     editable_lifetime = 300
     An order-level event involving a communication to the customer, such
     as an confirmation email being sent.
     """
-    order = models.ForeignKey('order.Order', related_name="communication_events")
-    event_type = models.ForeignKey('customer.CommunicationEventType')
-    date = models.DateTimeField(auto_now_add=True)
+    order = models.ForeignKey('order.Order', related_name="communication_events", verbose_name=_("Order"))
+    event_type = models.ForeignKey('customer.CommunicationEventType', verbose_name=_("Event Type"))
+    date = models.DateTimeField(_("Date"), auto_now_add=True)
 
     class Meta:
         abstract = True
     Not using a line model as it's difficult to capture and payment
     information when it splits across a line.
     """
-    order = models.ForeignKey('order.Order', related_name='lines')
+    order = models.ForeignKey('order.Order', related_name='lines', verbose_name=_("Order"))
 
     # We store the partner, their SKU and the title for cases where the product has been
     # deleted from the catalogue.  We also store the partner name in case the partner
     # gets deleted at a later date.
-    partner = models.ForeignKey('partner.Partner', related_name='order_lines', blank=True, null=True, on_delete=models.SET_NULL)
+    partner = models.ForeignKey('partner.Partner', related_name='order_lines', blank=True, null=True,
+        on_delete=models.SET_NULL, verbose_name=_("Partner"))
     partner_name = models.CharField(_("Partner name"), max_length=128)
     partner_sku = models.CharField(_("Partner SKU"), max_length=128)
 
 
     # We don't want any hard links between orders and the products table so we allow
     # this link to be NULLable.
-    product = models.ForeignKey('catalogue.Product', on_delete=models.SET_NULL, blank=True, null=True)
-    quantity = models.PositiveIntegerField(_('Quantity'), default=1)
+    product = models.ForeignKey('catalogue.Product', on_delete=models.SET_NULL, blank=True, null=True,
+        verbose_name=_("Product"))
+    quantity = models.PositiveIntegerField(_("Quantity"), default=1)
 
     # Price information (these fields are actually redundant as the information
     # can be calculated from the LinePrice models
-    line_price_incl_tax = models.DecimalField(_('Price (inc. tax)'), decimal_places=2, max_digits=12)
-    line_price_excl_tax = models.DecimalField(_('Price (excl. tax)'), decimal_places=2, max_digits=12)
+    line_price_incl_tax = models.DecimalField(_("Price (inc. tax)"), decimal_places=2, max_digits=12)
+    line_price_excl_tax = models.DecimalField(_("Price (excl. tax)"), decimal_places=2, max_digits=12)
 
     # Price information before discounts are applied
-    line_price_before_discounts_incl_tax = models.DecimalField(_('Price before discounts (inc. tax)'),
+    line_price_before_discounts_incl_tax = models.DecimalField(_("Price before discounts (inc. tax)"),
         decimal_places=2, max_digits=12)
-    line_price_before_discounts_excl_tax = models.DecimalField(_('Price before discounts (excl. tax)'),
+    line_price_before_discounts_excl_tax = models.DecimalField(_("Price before discounts (excl. tax)"),
         decimal_places=2, max_digits=12)
 
     # REPORTING FIELDS
     # Cost price (the price charged by the fulfilment partner for this product).
-    unit_cost_price = models.DecimalField(_('Unit Cost Price'), decimal_places=2, max_digits=12, blank=True, null=True)
+    unit_cost_price = models.DecimalField(_("Unit Cost Price"), decimal_places=2, max_digits=12, blank=True, null=True)
     # Normal site price for item (without discounts)
-    unit_price_incl_tax = models.DecimalField(_('Unit Price (inc. tax)'),decimal_places=2, max_digits=12,
+    unit_price_incl_tax = models.DecimalField(_("Unit Price (inc. tax)"),decimal_places=2, max_digits=12,
         blank=True, null=True)
-    unit_price_excl_tax = models.DecimalField(_('Unit Price (excl. tax)'), decimal_places=2, max_digits=12,
+    unit_price_excl_tax = models.DecimalField(_("Unit Price (excl. tax)"), decimal_places=2, max_digits=12,
         blank=True, null=True)
     # Retail price at time of purchase
-    unit_retail_price = models.DecimalField(_('Unit Retail Price'), decimal_places=2, max_digits=12,
+    unit_retail_price = models.DecimalField(_("Unit Retail Price"), decimal_places=2, max_digits=12,
         blank=True, null=True)
 
     # Partner information
     partner_line_reference = models.CharField(_("Partner reference"), max_length=128, blank=True, null=True,
         help_text=_("This is the item number that the partner uses within their system"))
-    partner_line_notes = models.TextField(_('Partner Notes'), blank=True, null=True)
+    partner_line_notes = models.TextField(_("Partner Notes"), blank=True, null=True)
 
     # Partners often want to assign some status to each line to help with their own
     # business processes.
     status = models.CharField(_("Status"), max_length=255, null=True, blank=True)
 
     # Estimated dispatch date - should be set at order time
-    est_dispatch_date = models.DateField(_('Estimated Dispatch Date'), blank=True, null=True)
+    est_dispatch_date = models.DateField(_("Estimated Dispatch Date"), blank=True, null=True)
 
     pipeline = getattr(settings,  'OSCAR_LINE_STATUS_PIPELINE', {})
 
 
     class Meta:
         abstract = True
-        verbose_name = _("Order line")
-        verbose_name_plural = _("Order lines")
+        verbose_name = _("Order Line")
+        verbose_name_plural = _("Order Lines")
 
     def __unicode__(self):
         if self.product:
 
 class AbstractLineAttribute(models.Model):
     u"""An attribute of a line."""
-    line = models.ForeignKey('order.Line', related_name='attributes')
-    option = models.ForeignKey('catalogue.Option', null=True, on_delete=models.SET_NULL, related_name="line_attributes")
+    line = models.ForeignKey('order.Line', related_name='attributes', verbose_name=_("Line"))
+    option = models.ForeignKey('catalogue.Option', null=True, on_delete=models.SET_NULL,
+        related_name="line_attributes", verbose_name=_("Option"))
     type = models.CharField(_("Type"), max_length=128)
     value = models.CharField(_("Value"), max_length=255)
 
     having different prices.  For example, one product may be sold at
     50% off as it's part of an offer while the remainder are full price.
     """
-    order = models.ForeignKey('order.Order', related_name='line_prices')
-    line = models.ForeignKey('order.Line', related_name='prices')
-    quantity = models.PositiveIntegerField(_('Quantity'), default=1)
-    price_incl_tax = models.DecimalField(_('Price (inc. tax)'), decimal_places=2, max_digits=12)
-    price_excl_tax = models.DecimalField(_('Price (excl. tax)'), decimal_places=2, max_digits=12)
-    shipping_incl_tax = models.DecimalField(_('Shiping (inc. tax)'), decimal_places=2, max_digits=12, default=0)
-    shipping_excl_tax = models.DecimalField(_('Shipping (excl. tax)'), decimal_places=2, max_digits=12, default=0)
+    order = models.ForeignKey('order.Order', related_name='line_prices', verbose_name=_("Option"))
+    line = models.ForeignKey('order.Line', related_name='prices', verbose_name=_("Line"))
+    quantity = models.PositiveIntegerField(_("Quantity"), default=1)
+    price_incl_tax = models.DecimalField(_("Price (inc. tax)"), decimal_places=2, max_digits=12)
+    price_excl_tax = models.DecimalField(_("Price (excl. tax)"), decimal_places=2, max_digits=12)
+    shipping_incl_tax = models.DecimalField(_("Shiping (inc. tax)"), decimal_places=2, max_digits=12, default=0)
+    shipping_excl_tax = models.DecimalField(_("Shipping (excl. tax)"), decimal_places=2, max_digits=12, default=0)
 
     class Meta:
         abstract = True
     """
     Payment events are things like 'Paid', 'Failed', 'Refunded'
     """
-    name = models.CharField(_('Name'), max_length=128, unique=True)
-    code = models.SlugField(_('Code'), max_length=128, unique=True)
-    sequence_number = models.PositiveIntegerField(_('Sequence'), default=0)
+    name = models.CharField(_("Name"), max_length=128, unique=True)
+    code = models.SlugField(_("Code"), max_length=128, unique=True)
+    sequence_number = models.PositiveIntegerField(_("Sequence"), default=0)
 
     def save(self, *args, **kwargs):
         if not self.code:
 
     class Meta:
         abstract = True
-        verbose_name = _("Payment event type")
-        verbose_name_plural = _("Payment event types")
+        verbose_name = _("Payment Event Type")
+        verbose_name_plural = _("Payment Event Types")
         ordering = ('sequence_number',)
 
     def __unicode__(self):
     An event is something which happens to a line such as
     payment being taken for 2 items, or 1 item being dispatched.
     """
-    order = models.ForeignKey('order.Order', related_name='payment_events')
-    amount = models.DecimalField(_('Amount'), decimal_places=2, max_digits=12)
-    lines = models.ManyToManyField('order.Line', through='PaymentEventQuantity')
-    event_type = models.ForeignKey('order.PaymentEventType')
-    date = models.DateTimeField(auto_now_add=True)
+    order = models.ForeignKey('order.Order', related_name='payment_events', verbose_name=_("Order"))
+    amount = models.DecimalField(_("Amount"), decimal_places=2, max_digits=12)
+    lines = models.ManyToManyField('order.Line', through='PaymentEventQuantity', verbose_name=_("Lines"))
+    event_type = models.ForeignKey('order.PaymentEventType', verbose_name=_("Event Type"))
+    date = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     class Meta:
         abstract = True
-        verbose_name = _("Payment event")
-        verbose_name_plural = _("Payment events")
+        verbose_name = _("Payment Event")
+        verbose_name_plural = _("Payment Events")
 
     def __unicode__(self):
         return _("Payment event for order %s") % self.order
     """
     A "through" model linking lines to payment events
     """
-    event = models.ForeignKey('order.PaymentEvent', related_name='line_quantities')
-    line = models.ForeignKey('order.Line')
-    quantity = models.PositiveIntegerField(_('Quantity'))
+    event = models.ForeignKey('order.PaymentEvent', related_name='line_quantities', verbose_name=_("Event"))
+    line = models.ForeignKey('order.Line', verbose_name=_("Line"))
+    quantity = models.PositiveIntegerField(_("Quantity"))
 
     class Meta:
         verbose_name = _("Payment Event Quantity")
     An event is something which happens to a group of lines such as
     1 item being dispatched.
     """
-    order = models.ForeignKey('order.Order', related_name='shipping_events')
-    lines = models.ManyToManyField('order.Line', through='ShippingEventQuantity')
-    event_type = models.ForeignKey('order.ShippingEventType')
+    order = models.ForeignKey('order.Order', related_name='shipping_events', verbose_name=_("Order"))
+    lines = models.ManyToManyField('order.Line', through='ShippingEventQuantity', verbose_name=_("Lines"))
+    event_type = models.ForeignKey('order.ShippingEventType', verbose_name=_("Event Type"))
     notes = models.TextField(_("Event notes"), blank=True, null=True,
         help_text=_("This could be the dispatch reference, or a tracking number"))
-    date = models.DateTimeField(auto_now_add=True)
+    date = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     class Meta:
         abstract = True
-        verbose_name = _("Shipping event")
-        verbose_name_plural = _("Shipping events")
+        verbose_name = _("Shipping Event")
+        verbose_name_plural = _("Shipping Events")
         ordering = ['-date']
 
     def __unicode__(self):
     """
     A "through" model linking lines to shipping events
     """
-    event = models.ForeignKey('order.ShippingEvent', related_name='line_quantities')
-    line = models.ForeignKey('order.Line')
-    quantity = models.PositiveIntegerField(_('Quantity'))
+    event = models.ForeignKey('order.ShippingEvent', related_name='line_quantities', verbose_name=_("Event"))
+    line = models.ForeignKey('order.Line', verbose_name=_("Line"))
+    quantity = models.PositiveIntegerField(_("Quantity"))
 
     class Meta:
         verbose_name = _("Shipping Event Quantity")
         super(ShippingEventQuantity, self).save(*args, **kwargs)
 
     def __unicode__(self):
-        return _(u"%(product)s - quantity %(qty)d") % {'product': self.line.product, 'qty': self.quantity}
+        return _("%(product)s - quantity %(qty)d") % {'product': self.line.product, 'qty': self.quantity}
 
 
 class AbstractShippingEventType(models.Model):
     Shipping events are things like 'OrderPlaced', 'Acknowledged', 'Dispatched', 'Refunded'
     """
     # Name is the friendly description of an event
-    name = models.CharField(_('Name'), max_length=255, unique=True)
+    name = models.CharField(_("Name"), max_length=255, unique=True)
     # Code is used in forms
-    code = models.SlugField(_('Code'), max_length=128, unique=True)
-    is_required = models.BooleanField(_('Is Required'), default=True,
+    code = models.SlugField(_("Code"), max_length=128, unique=True)
+    is_required = models.BooleanField(_("Is Required"), default=True,
         help_text=_("This event must be passed before the next shipping event can take place"))
     # The normal order in which these shipping events take place
-    sequence_number = models.PositiveIntegerField(_('Sequence'), default=0)
+    sequence_number = models.PositiveIntegerField(_("Sequence"), default=0)
 
     def save(self, *args, **kwargs):
         if not self.code:
 
     class Meta:
         abstract = True
-        verbose_name = _("Shipping event type")
-        verbose_name_plural = _("Shipping event types")
+        verbose_name = _("Shipping Event Type")
+        verbose_name_plural = _("Shipping Event Types")
         ordering = ('sequence_number',)
 
     def __unicode__(self):
     Normally only used for display purposes so an order can be listed with discounts displayed
     separately even though in reality, the discounts are applied at the line level.
     """
-    order = models.ForeignKey('order.Order', related_name="discounts")
-    offer_id = models.PositiveIntegerField(_('Offer ID'), blank=True, null=True)
-    voucher_id = models.PositiveIntegerField(_('Voucher ID'), blank=True, null=True)
+    order = models.ForeignKey('order.Order', related_name="discounts", verbose_name=_("Order"))
+    offer_id = models.PositiveIntegerField(_("Offer ID"), blank=True, null=True)
+    voucher_id = models.PositiveIntegerField(_("Voucher ID"), blank=True, null=True)
     voucher_code = models.CharField(_("Code"), max_length=128, db_index=True, null=True)
-    amount = models.DecimalField(_('Amount'), decimal_places=2, max_digits=12, default=0)
+    amount = models.DecimalField(_("Amount"), decimal_places=2, max_digits=12, default=0)
 
     class Meta:
         abstract = True

oscar/apps/partner/abstract_models.py

     """
     Fulfillment partner
     """
-    name = models.CharField(_('Name'), max_length=128, unique=True)
+    name = models.CharField(_("Name"), max_length=128, unique=True)
 
     # A partner can have users assigned to it.  These can be used
     # to provide authentication for webservices etc.
-    users = models.ManyToManyField('auth.User', related_name="partners", blank=True, null=True)
+    users = models.ManyToManyField('auth.User', related_name="partners", blank=True, null=True,
+        verbose_name=_("Users"))
 
     class Meta:
-        verbose_name = _('Fulfillment partner')
-        verbose_name_plural = _('Fulfillment partners')
+        verbose_name = _('Fulfillment Partner')
+        verbose_name_plural = _('Fulfillment Partners')
         abstract = True
         permissions = (
             ("can_edit_stock_records", _("Can edit stock records")),
     We deliberately don't store tax information to allow each project
     to subclass this model and put its own fields for convey tax.
     """
-    product = models.OneToOneField('catalogue.Product', related_name="stockrecord")
-    partner = models.ForeignKey('partner.Partner')
+    product = models.OneToOneField('catalogue.Product', related_name="stockrecord", verbose_name=_("Product"))
+    partner = models.ForeignKey('partner.Partner', verbose_name=_("Partner"))
 
     # The fulfilment partner will often have their own SKU for a product, which
     # we store here.
     partner_sku = models.CharField(_("Partner SKU"), max_length=128)
 
     # Price info:
-    price_currency = models.CharField(_('Currency'), max_length=12, default=settings.OSCAR_DEFAULT_CURRENCY)
+    price_currency = models.CharField(_("Currency"), max_length=12, default=settings.OSCAR_DEFAULT_CURRENCY)
 
     # This is the base price for calculations - tax should be applied
     # by the appropriate method.  We don't store it here as its calculation is
     # highly domain-specific.  It is NULLable because some items don't have a fixed
     # price.
-    price_excl_tax = models.DecimalField(_('Price (excl. tax)'), decimal_places=2, max_digits=12, blank=True, null=True)
+    price_excl_tax = models.DecimalField(_("Price (excl. tax)"), decimal_places=2, max_digits=12, blank=True, null=True)
 
     # Retail price for this item
-    price_retail = models.DecimalField(_('Price (retail)'), decimal_places=2, max_digits=12, blank=True, null=True)
+    price_retail = models.DecimalField(_("Price (retail)"), decimal_places=2, max_digits=12, blank=True, null=True)
 
     # Cost price is optional as not all partners supply it
-    cost_price = models.DecimalField(_('Cost Price'), decimal_places=2, max_digits=12, blank=True, null=True)
+    cost_price = models.DecimalField(_("Cost Price"), decimal_places=2, max_digits=12, blank=True, null=True)
 
     # Stock level information
-    num_in_stock = models.PositiveIntegerField(_('Number in stock'), default=0, blank=True, null=True)
+    num_in_stock = models.PositiveIntegerField(_("Number in stock"), default=0, blank=True, null=True)
 
     # Threshold for low-stock alerts
-    low_stock_threshold = models.PositiveIntegerField(_('Low Stock Threshold'), blank=True, null=True)
+    low_stock_threshold = models.PositiveIntegerField(_("Low Stock Threshold"), blank=True, null=True)
 
     # The amount of stock allocated to orders but not fed back to the master
     # stock system.  A typical stock update process will set the num_in_stock
     # variable to a new value and reset num_allocated to zero
-    num_allocated = models.IntegerField(_('Number of Allocated'), default=0, blank=True, null=True)
+    num_allocated = models.IntegerField(_("Number of Allocated"), default=0, blank=True, null=True)
 
     # Date information
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_updated = models.DateTimeField(auto_now=True, db_index=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+    date_updated = models.DateTimeField(_("Date Updated"), auto_now=True, db_index=True)
 
     class Meta:
         abstract = True
 
 
 class AbstractStockAlert(models.Model):
-    stockrecord = models.ForeignKey('partner.StockRecord', related_name='alerts')
-    threshold = models.PositiveIntegerField(_('Threshold'))
-    OPEN, CLOSED = 'Open', 'Closed'
+    stockrecord = models.ForeignKey('partner.StockRecord', related_name='alerts', verbose_name=_("Stock Record"))
+    threshold = models.PositiveIntegerField(_("Threshold"))
+    OPEN, CLOSED = "Open", "Closed"
     status_choices = (
-        (OPEN, _('Open')),
-        (CLOSED, _('Closed')),
+        (OPEN, _("Open")),
+        (CLOSED, _("Closed")),
     )
-    status = models.CharField(max_length=128, default=OPEN, choices=status_choices)
-    date_created = models.DateTimeField(auto_now_add=True)
-    date_closed = models.DateTimeField(blank=True, null=True)
+    status = models.CharField(_("Status"), max_length=128, default=OPEN, choices=status_choices)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
+    date_closed = models.DateTimeField(_("Date Closed"), blank=True, null=True)
 
     def close(self):
         self.status = self.CLOSED

oscar/apps/payment/models.py

     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')
+    source = models.ForeignKey('payment.Source', related_name='transactions', verbose_name=_("Source"))
     
     # We define some sample types
     AUTHORISE, DEBIT, REFUND = 'Authorise', 'Debit', 'Refund'
-    txn_type = models.CharField(_('Type'), max_length=128, blank=True)
-    amount = models.DecimalField(_('Amount'), decimal_places=2, max_digits=12)
-    reference = models.CharField(_('Reference'), max_length=128, null=True)
-    status = models.CharField(_('Status'), max_length=128, null=True)
-    date_created = models.DateTimeField(auto_now_add=True)
+    txn_type = models.CharField(_("Type"), max_length=128, blank=True)
+    amount = models.DecimalField(_("Amount"), decimal_places=2, max_digits=12)
+    reference = models.CharField(_("Reference"), max_length=128, null=True)
+    status = models.CharField(_("Status"), max_length=128, null=True)
+    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}
     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')
-    source_type = models.ForeignKey('payment.SourceType')
-    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'))
+    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)
+    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)
+    label = models.CharField(_("Label"), max_length=128, blank=True, null=True)
     
     # A dictionary of submission data that is stored as part of the
     # checkout process.
     This could be an external partner like PayPal or DataCash,
     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
+    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"""))
 
     class Meta:
     
 
 class Bankcard(models.Model):
-    user = models.ForeignKey('auth.User', related_name='bankcards')
-    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'))
+    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

     position = models.CharField(_("Position"), max_length=100, help_text="Position on page")
     display_order = models.PositiveIntegerField(_("Display Order"), default=0)
     clicks = models.PositiveIntegerField(_("Clicks"), default=0)
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     class Meta:
         abstract = True
     products.
     """
     _type = 'Product list'
-    products = models.ManyToManyField('catalogue.Product', through='OrderedProduct', blank=True, null=True)
+    products = models.ManyToManyField('catalogue.Product', through='OrderedProduct', blank=True, null=True,
+        verbose_name=_("Products"))
 
     def get_queryset(self):
         return self.products.all().order_by('%s.display_order' % OrderedProduct._meta.db_table)
 
 class OrderedProduct(models.Model):
 
-    list = models.ForeignKey('promotions.HandPickedProductList')
-    product = models.ForeignKey('catalogue.Product')
+    list = models.ForeignKey('promotions.HandPickedProductList', verbose_name=_("List"))
+    product = models.ForeignKey('catalogue.Product', verbose_name=_("Product"))
     display_order = models.PositiveIntegerField(_('Display Order'), default=0)
 
     class Meta:
 
 class OrderedProductList(HandPickedProductList):
     tabbed_block = models.ForeignKey('promotions.TabbedBlock',
-                                     related_name='tabs')
+                                     related_name='tabs', verbose_name=_("Tabbed Block"))
     display_order = models.PositiveIntegerField(_('Display Order'), default=0)
 
     class Meta:
 
     _type = 'Tabbed block'
     name = models.CharField(_("Title"), max_length=255)
-    date_created = models.DateTimeField(auto_now_add=True)
+    date_created = models.DateTimeField(_("Date Created"), auto_now_add=True)
 
     class Meta:
         verbose_name = _("Tabbed Block")

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)
+    countries = models.ManyToManyField('address.Country', null=True, blank=True, verbose_name=_("Countries"))
 
     _basket = None
 
     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:
-        verbose_name = _('Order and item charge')
-        verbose_name_plural = _('Order and item charges')
+        verbose_name = _("Order and Item Charge")
+        verbose_name_plural = _("Order and Item Charges")
 
     def set_basket(self, basket):
         self._basket = basket
 
 
 class WeightBased(ShippingMethod):
-    upper_charge = models.DecimalField(_('Upper Charge'), decimal_places=2, max_digits=12, null=True,
+    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'),
+    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')
+        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)
     """
     Represents a weight band which are used by the WeightBasedShipping method.
     """
-    method = models.ForeignKey(WeightBased, related_name='bands')
-    upper_limit = models.FloatField(_('Upper Limit'), help_text=_("""Enter upper limit of this
+    method = models.ForeignKey(WeightBased, related_name='bands', verbose_name=_("Method"))
+    upper_limit = models.FloatField(_("Upper Limit"), help_text=_("""Enter upper limit of this
                                                 weight band in Kg, the lower
                                                 limit will be determine by the
                                                 other weight bands"""))
-    charge = models.DecimalField(_('Charge'), decimal_places=2, max_digits=12)
+    charge = models.DecimalField(_("Charge"), decimal_places=2, max_digits=12)
     
     @property
     def weight_from(self):

oscar/apps/voucher/abstract_models.py

         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',
+    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')
     end_date = models.DateField(_('End Date'))
 
     # Audit information
-    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'))
+    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'))
     
     date_created = models.DateField(auto_now_add=True)
 
     """
     For tracking how often a voucher has been used
     """
-    voucher = models.ForeignKey('voucher.Voucher', related_name="applications")
+    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)
-    order = models.ForeignKey('order.Order')
-    date_created = models.DateField(auto_now_add=True)
+    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)
 
     class Meta:
         abstract = True