Removed numbering from the models.py header of some test packages.

This is a reliqua from the early days of the modeltests/regressiontests era.

tests/basic/models.py

 # -*- coding: utf-8 -*-
 """
-1. Bare-bones model
+Bare-bones model
 
 This is a basic model with only two non-primary-key fields.
 """

tests/choices/models.py

 """
-21. Specifying 'choices' for a field
+Specifying 'choices' for a field
 
 Most fields take a ``choices`` parameter, which should be a tuple of tuples
 specifying which are the valid values for that field.

tests/custom_columns/models.py

 """
-17. Custom column/table names
+Custom column/table names
 
 If your database column name is different than your model attribute, use the
 ``db_column`` parameter. Note that you'll use the field's name, not its column

tests/custom_managers/models.py

 """
-23. Giving models a custom manager
+Giving models a custom manager
 
 You can use a custom ``Manager`` in a particular model by extending the base
 ``Manager`` class and instantiating your custom ``Manager`` in your model.

tests/custom_methods/models.py

 """
-3. Giving models custom methods
+Giving models custom methods
 
 Any method you add to a model will be available to instances.
 """

tests/custom_pk/models.py

 # -*- coding: utf-8 -*-
 """
-14. Using a custom primary key
+Using a custom primary key
 
 By default, Django adds an ``"id"`` field to each model. But you can override
 this behavior by explicitly adding ``primary_key=True`` to a field.

tests/empty/models.py

 """
-40. Empty model tests
+Empty model tests
 
 These test that things behave sensibly for the rare corner-case of a model with
 no fields.

tests/field_defaults/models.py

 # coding: utf-8
 """
-32. Callable defaults
+Callable defaults
 
 You can pass callable objects as the ``default`` parameter to a field. When
 the object is created without an explicit value passed in, Django will call

tests/file_storage/models.py

 """
-42. Storing files according to a custom storage system
+Storing files according to a custom storage system
 
 ``FileField`` and its variations can take a ``storage`` argument to specify how
 and where files should be stored.

tests/fixtures/models.py

 """
-37. Fixtures.
+Fixtures.
 
 Fixtures are a way of loading data into the database in bulk. Fixure data
 can be stored in any serializable format (including JSON and XML). Fixtures

tests/generic_relations/models.py

 """
-34. Generic relations
+Generic relations
 
 Generic relations let an object have a foreign key to any object through a
 content-type/object-id field. A ``GenericForeignKey`` field can point to any

tests/get_object_or_404/models.py

 """
-35. DB-API Shortcuts
+DB-API Shortcuts
 
 ``get_object_or_404()`` is a shortcut function to be used in view functions for
 performing a ``get()`` lookup and raising a ``Http404`` exception if a

tests/lookup/models.py

 """
-7. The lookup API
+The lookup API
 
 This demonstrates features of the database API.
 """

tests/m2m_and_m2o/models.py

 """
-29. Many-to-many and many-to-one relationships to the same table
+Many-to-many and many-to-one relationships to the same table
 
 Make sure to set ``related_name`` if you use relationships to the same table.
 """

tests/m2m_intermediary/models.py

 """
-9. Many-to-many relationships via an intermediary table
+Many-to-many relationships via an intermediary table
 
 For many-to-many relationships that need extra fields on the intermediary
 table, use an intermediary model.

tests/m2m_multiple/models.py

 """
-20. Multiple many-to-many relationships between the same two tables
+Multiple many-to-many relationships between the same two tables
 
 In this example, an ``Article`` can have many "primary" ``Category`` objects
 and many "secondary" ``Category`` objects.

tests/m2m_recursive/models.py

 """
-28. Many-to-many relationships between the same two tables
+Many-to-many relationships between the same two tables
 
 In this example, a ``Person`` can have many friends, who are also ``Person``
 objects. Friendship is a symmetrical relationship - if I am your friend, you

tests/m2o_recursive/models.py

 """
-11. Relating an object to itself, many-to-one
+Relating an object to itself, many-to-one
 
 To define a many-to-one relationship between a model and itself, use
 ``ForeignKey('self')``.

tests/many_to_many/models.py

 """
-5. Many-to-many relationships
+Many-to-many relationships
 
 To define a many-to-many relationship, use ``ManyToManyField()``.
 

tests/many_to_one/models.py

 """
-4. Many-to-one relationships
+Many-to-one relationships
 
 To define a many-to-one relationship, use ``ForeignKey()``.
 """

tests/many_to_one_null/models.py

 """
-16. Many-to-one relationships that can be null
+Many-to-one relationships that can be null
 
 To define a many-to-one relationship that can have a null foreign key, use
 ``ForeignKey()`` with ``null=True`` .

tests/mutually_referential/models.py

 """
-24. Mutually referential many-to-one relationships
+Mutually referential many-to-one relationships
 
 Strings can be used instead of model literals to set up "lazy" relations.
 """

tests/one_to_one/models.py

 """
-10. One-to-one relationships
+One-to-one relationships
 
 To define a one-to-one relationship, use ``OneToOneField()``.
 

tests/or_lookups/models.py

 """
-19. OR lookups
+OR lookups
 
 To perform an OR lookup, or a lookup that combines ANDs and ORs, combine
 ``QuerySet`` objects using ``&`` and ``|`` operators.

tests/ordering/models.py

 """
-6. Specifying ordering
+Specifying ordering
 
 Specify default ordering for a model using the ``ordering`` attribute, which
 should be a list or tuple of field names. This tells Django how to order

tests/properties/models.py

 """
-22. Using properties on models
+Using properties on models
 
 Use properties on models just like on any other Python object.
 """

tests/reserved_names/models.py

 """
-18. Using SQL reserved names
+Using SQL reserved names
 
 Need to use a reserved SQL name as a column name or table name? Need to include
 a hyphen in a column or table name? No problem. Django quotes names

tests/reverse_lookup/models.py

 """
-25. Reverse lookups
+Reverse lookups
 
 This demonstrates the reverse lookup features of the database API.
 """

tests/save_delete_hooks/models.py

 """
-13. Adding hooks before/after saving and deleting
+Adding hooks before/after saving and deleting
 
 To execute arbitrary code around ``save()`` and ``delete()``, just subclass
 the methods.

tests/select_related/models.py

 """
-41. Tests for select_related()
+Tests for select_related()
 
 ``select_related()`` follows all relationships and pre-caches any foreign key
 values so that complex trees can be fetched in a single query. However, this

tests/serializers/models.py

 # -*- coding: utf-8 -*-
 """
-42. Serialization
+Serialization
 
 ``django.core.serializers`` provides interfaces to converting Django
 ``QuerySet`` objects to and from "flat" data (i.e. strings).

tests/str/models.py

 # -*- coding: utf-8 -*-
 """
-2. Adding __str__() or __unicode__() to models
+Adding __str__() or __unicode__() to models
 
 Although it's not a strict requirement, each model should have a
 ``_str__()`` or ``__unicode__()`` method to return a "human-readable"

tests/test_client/tests.py

 # -*- coding: utf-8 -*-
 """
-39. Testing using the Test Client
+Testing using the Test Client
 
 The test client is a class that can act like a simple
 browser for testing purposes.

tests/transactions/models.py

 """
-15. Transactions
+Transactions
 
 Django handles transactions in three different ways. The default is to commit
 each transaction upon a write, but you can decorate a function to get

tests/user_commands/models.py

 """
-38. User-registered management commands
+User-registered management commands
 
 The ``manage.py`` utility provides a number of useful commands for managing a
 Django project. If you want to add a utility command of your own, you can.