Merge pull request #1129 from frog32/master

Add needed Imports to the Documentation

6 files changed, 42 insertions, 2 deletions

diff --git a/docs/ref/models/fields.txt b/docs/ref/models/fields.txt
index 6cf235c637..c5f2609bab 100644
--- a/docs/ref/models/fields.txt
+++ b/docs/ref/models/fields.txt
@@ -98,6 +98,8 @@ second element is the human-readable name. For example::
 Generally, it's best to define choices inside a model class, and to
 define a suitably-named constant for each value::
 
+    from django.db import models
+
     class Student(models.Model):
         FRESHMAN = 'FR'
         SOPHOMORE = 'SO'
@@ -997,12 +999,15 @@ relationship with itself -- use ``models.ForeignKey('self')``.
 If you need to create a relationship on a model that has not yet been defined,
 you can use the name of the model, rather than the model object itself::
 
+    from django.db import models
+
     class Car(models.Model):
         manufacturer = models.ForeignKey('Manufacturer')
         # ...
 
     class Manufacturer(models.Model):
         # ...
+        pass
 
 To refer to models defined in another application, you can explicitly specify
 a model with the full application label. For example, if the ``Manufacturer``
@@ -1135,6 +1140,9 @@ The possible values for :attr:`~ForeignKey.on_delete` are found in
     necessary to avoid executing queries at the time your models.py is
     imported::
 
+        from django.db import models
+        from django.contrib.auth.models import User
+
         def get_sentinel_user():
             return User.objects.get_or_create(username='deleted')[0]
 
@@ -1207,6 +1215,8 @@ that control how the relationship functions.
     Only used in the definition of ManyToManyFields on self. Consider the
     following model::
 
+        from django.db import models
+
         class Person(models.Model):
             friends = models.ManyToManyField("self")
 
diff --git a/docs/ref/models/instances.txt b/docs/ref/models/instances.txt
index b4b162a9ea..f989ff1bec 100644
--- a/docs/ref/models/instances.txt
+++ b/docs/ref/models/instances.txt
@@ -34,6 +34,8 @@ that, you need to :meth:`~Model.save()`.
 
     1. Add a classmethod on the model class::
 
+        from django.db import models
+
         class Book(models.Model):
             title = models.CharField(max_length=100)
 
@@ -105,6 +107,7 @@ individually.
 You'll need to call ``full_clean`` manually when you want to run one-step model
 validation for your own manually created models. For example::
 
+    from django.core.exceptions import ValidationError
     try:
         article.full_clean()
     except ValidationError as e:
@@ -132,6 +135,7 @@ automatically provide a value for a field, or to do validation that requires
 access to more than a single field::
 
     def clean(self):
+        import datetime
         from django.core.exceptions import ValidationError
         # Don't allow draft entries to have a pub_date.
         if self.status == 'draft' and self.pub_date is not None:
@@ -434,6 +438,8 @@ representation of the model from the ``__unicode__()`` method.
 
 For example::
 
+    from django.db import models
+
     class Person(models.Model):
         first_name = models.CharField(max_length=50)
         last_name = models.CharField(max_length=50)
@@ -460,6 +466,9 @@ Thus, you should return a nice, human-readable string for the object's
 The previous :meth:`~Model.__unicode__()` example could be similarly written
 using ``__str__()`` like this::
 
+    from django.db import models
+    from django.utils.encoding import force_bytes
+
     class Person(models.Model):
         first_name = models.CharField(max_length=50)
         last_name = models.CharField(max_length=50)
@@ -490,6 +499,7 @@ function is usually the best approach.)
 For example::
 
     def get_absolute_url(self):
+        from django.core.urlresolvers import reverse
         return reverse('people.views.details', args=[str(self.id)])
 
 One place Django uses ``get_absolute_url()`` is in the admin app. If an object
diff --git a/docs/ref/models/options.txt b/docs/ref/models/options.txt
index 5f9316bd2a..90099d13a3 100644
--- a/docs/ref/models/options.txt
+++ b/docs/ref/models/options.txt
@@ -145,6 +145,12 @@ Django quotes column and table names behind the scenes.
     and a question has more than one answer, and the order of answers matters, you'd
     do this::
 
+        from django.db import models
+
+        class Question(models.Model):
+            text = models.TextField()
+            # ...
+
         class Answer(models.Model):
             question = models.ForeignKey(Question)
             # ...
diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt
index 14123cd79a..9677b321c6 100644
--- a/docs/ref/models/querysets.txt
+++ b/docs/ref/models/querysets.txt
@@ -232,6 +232,7 @@ the model field that is being aggregated.
 For example, if you were manipulating a list of blogs, you may want
 to determine how many entries have been made in each blog::
 
+    >>> from django.db.models import Count
     >>> q = Blog.objects.annotate(Count('entry'))
     # The name of the first blog
     >>> q[0].name
@@ -699,6 +700,8 @@ And here's ``select_related`` lookup::
 ``select_related()`` follows foreign keys as far as possible. If you have the
 following models::
 
+    from django.db import models
+
     class City(models.Model):
         # ...
         pass
@@ -814,6 +817,8 @@ that are supported by ``select_related``. It also supports prefetching of
 
 For example, suppose you have these models::
 
+    from django.db import models
+
     class Topping(models.Model):
         name = models.CharField(max_length=30)
 
@@ -1565,6 +1570,7 @@ aggregated.
 For example, when you are working with blog entries, you may want to know the
 number of authors that have contributed blog entries::
 
+    >>> from django.db.models import Count
     >>> q = Blog.objects.aggregate(Count('entry'))
     {'entry__count': 16}
 
@@ -2042,6 +2048,7 @@ Range test (inclusive).
 
 Example::
 
+    import datetime
     start_date = datetime.date(2005, 1, 1)
     end_date = datetime.date(2005, 3, 31)
     Entry.objects.filter(pub_date__range=(start_date, end_date))
diff --git a/docs/ref/models/relations.txt b/docs/ref/models/relations.txt
index c923961a19..ffebe37193 100644
--- a/docs/ref/models/relations.txt
+++ b/docs/ref/models/relations.txt
@@ -12,8 +12,11 @@ Related objects reference
     * The "other side" of a :class:`~django.db.models.ForeignKey` relation.
       That is::
 
+            from django.db import models
+
             class Reporter(models.Model):
-                ...
+                # ...
+                pass
 
             class Article(models.Model):
                 reporter = models.ForeignKey(Reporter)
@@ -24,7 +27,8 @@ Related objects reference
     * Both sides of a :class:`~django.db.models.ManyToManyField` relation::
 
             class Topping(models.Model):
-                ...
+                # ...
+                pass
 
             class Pizza(models.Model):
                 toppings = models.ManyToManyField(Topping)
diff --git a/docs/ref/template-response.txt b/docs/ref/template-response.txt
index cdefe2fae8..4f34d150ed 100644
--- a/docs/ref/template-response.txt
+++ b/docs/ref/template-response.txt
@@ -215,6 +215,7 @@ re-rendered, you can re-evaluate the rendered content, and assign
 the content of the response manually::
 
     # Set up a rendered TemplateResponse
+    >>> from django.template.response import TemplateResponse
     >>> t = TemplateResponse(request, 'original.html', {})
     >>> t.render()
     >>> print(t.content)
@@ -256,6 +257,8 @@ To define a post-render callback, just define a function that takes
 a single argument -- response -- and register that function with
 the template response::
 
+    from django.template.response import TemplateResponse
+
     def my_render_callback(response):
         # Do content-sensitive processing
         do_post_processing()