Context Navigation

Back to Ticket #8991

Ticket #8991: django.git-docs-trunk.patch

File django.git-docs-trunk.patch, 60.2 KB (added by Marc Fargas, 16 years ago)
Fix.

docs/howto/custom-management-commands.txt

From: Marc Fargas <telenieko@telenieko.com>
Date: Tue, 9 Sep 2008 15:16:29 +0000 (+0200)
Subject: And the last ones.
X-Git-Url: http://www.marcfargas.com/gitweb/?p=django.git;a=commitdiff_plain;h=docs-trunk;hp=master

And the last ones.
---

diff --git a/docs/howto/custom-management-commands.txt b/docs/howto/custom-management-commands.txt
index b6cc850..277622b 100644

-              a
 Writing custom django-admin commands
 ====================================
-.. versionadded:: 1.0
 Applications can register their own actions with ``manage.py``. For example,
 you might want to add a ``manage.py`` action for a Django app that you're
 distributing.
-…
+               The ``explode.py`` module has only one requirement -- it must define a class
 called ``Command`` that extends ``django.core.management.base.BaseCommand``.
 For more details on how to define your own commands, look at the code for the
+existing ``django-admin.py`` commands, in ``/django/core/management/commands``.
+ No newline at end of file
+existing ``django-admin.py`` commands, in ``/django/core/management/commands``.

docs/howto/custom-model-fields.txt

diff --git a/docs/howto/custom-model-fields.txt b/docs/howto/custom-model-fields.txt
index 9364384..63c428e 100644

-              a
 Writing custom model fields
 ===========================
-.. versionadded:: 1.0
 Introduction
 ============

docs/howto/custom-template-tags.txt

diff --git a/docs/howto/custom-template-tags.txt b/docs/howto/custom-template-tags.txt
index e1ddefe..ab699ac 100644

                will use the function's name as the filter name.
 Filters and auto-escaping
 ~~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 When writing a custom filter, give some thought to how the filter will interact
 with Django's auto-escaping behavior. Note that three types of strings can be
 passed around inside the template code:
-…
+               without having to be parsed multiple times.
 Auto-escaping considerations
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 The output from template tags is **not** automatically run through the
 auto-escaping filters. However, there are still a couple of things you should
 keep in mind when writing a template tag.
-…
+               Now your tag should begin to look like this::
 You also have to change the renderer to retrieve the actual contents of the
 ``date_updated`` property of the ``blog_entry`` object.  This can be
+accomplished by using the ``resolve_variable()`` function in
+``django.template``. You pass ``resolve_variable()`` the variable name and the
+current context, available in the ``render`` method::
+accomplished by using the ``Variable()`` class in ``django.template``.
+To use the ``Variable`` class, simply instantiate it with the name of the
+variable to be resolved, and then call ``variable.resolve(context)``. So,
+for example::
-    from django import template
-    from django.template import resolve_variable
-    import datetime
     class FormatTimeNode(template.Node):
         def __init__(self, date_to_be_formatted, format_string):
             self.date_to_be_formatted = date_to_be_formatted
+            self.date_to_be_formatted = Variable(date_to_be_formatted)
             self.format_string = format_string
         def render(self, context):
             try:
                 actual_date = resolve_variable(self.date_to_be_formatted, context)
+                actual_date = self.date_to_be_formatted.resolve(context)
                 return actual_date.strftime(self.format_string)
             except template.VariableDoesNotExist:
                 return ''
-``resolve_variable`` will try to resolve ``blog_entry.date_updated`` and then
-format it accordingly.
-.. versionadded:: 1.0
-    Variable resolution has changed in the development version of Django.
-    ``template.resolve_variable()`` is still available, but has been deprecated
-    in favor of a new ``template.Variable`` class. Using this class will usually
-    be more efficient than calling ``template.resolve_variable``
-    To use the ``Variable`` class, simply instantiate it with the name of the
-    variable to be resolved, and then call ``variable.resolve(context)``. So,
-    in the development version, the above example would be more correctly
-    written as:
-    .. parsed-literal::
-        class FormatTimeNode(template.Node):
-            def __init__(self, date_to_be_formatted, format_string):
-                self.date_to_be_formatted = **Variable(date_to_be_formatted)**
-                self.format_string = format_string
-            def render(self, context):
-                try:
-                    actual_date = **self.date_to_be_formatted.resolve(context)**
-                    return actual_date.strftime(self.format_string)
-                except template.VariableDoesNotExist:
-                    return ''
-    Changes are highlighted in bold.
 Variable resolution will throw a ``VariableDoesNotExist`` exception if it cannot
 resolve the string passed to it in the current context of the page.

docs/howto/deployment/modpython.txt

diff --git a/docs/howto/deployment/modpython.txt b/docs/howto/deployment/modpython.txt
index 7612b40..cac6565 100644

                This tells Apache: "Use mod_python for any URL at or under '/mysite/', using the
 Django mod_python handler." It passes the value of :ref:`DJANGO_SETTINGS_MODULE
 <django-settings-module>` so mod_python knows which settings to use.
-.. versionadded:: 1.0
-    The ``PythonOption django.root ...`` is new in this version.
 Because mod_python does not know we are
 serving this site from underneath the ``/mysite/`` prefix, this value needs to
 be passed through to the mod_python handler in Django, via the ``PythonOption

docs/internals/contributing.txt

diff --git a/docs/internals/contributing.txt b/docs/internals/contributing.txt
index 52b52d6..eda463a 100644

                General improvements, or other changes to the APIs that should be emphasised
 should use the ".. versionchanged:: X.Y" directive (with the same format as the
 ``versionadded`` mentioned above.
+In case you doubt about which version to write on the note just leave it as "X.Y",
+or the version currently being developed. The person commiting your change will
+make sure it has the proper version number.
 Guidelines for ReST files
 -------------------------

docs/ref/contrib/flatpages.txt

diff --git a/docs/ref/contrib/flatpages.txt b/docs/ref/contrib/flatpages.txt
index f1c3a1b..46a81a0 100644

                Django comes with an optional "flatpages" application. It lets you store simple
 "flat" HTML content in a database and handles the management for you via
 Django's admin interface and a Python API.
 A flatpage is a simple object with a URL, title and content. Use it for
+A flatpage is a simple object with a URL, title an optional content. Use it for
 one-off, special-case pages, such as "About" or "Privacy Policy" pages, that
 you want to store in a database but for which you don't want to develop a
 custom Django application.
-…
+               custom Django application.
 A flatpage can use a custom template or a default, systemwide flatpage
 template. It can be associated with one, or multiple, sites.
-.. versionadded:: 1.0
-The content field may optionally be left blank if you prefer to put your
-content in a custom template.
 Here are some examples of flatpages on Django-powered sites:
     * http://www.chicagocrime.org/about/

docs/ref/contrib/formtools/form-wizard.txt

diff --git a/docs/ref/contrib/formtools/form-wizard.txt b/docs/ref/contrib/formtools/form-wizard.txt
index cf57e79..9400d87 100644

                Form wizard
 .. module:: django.contrib.formtools.wizard
     :synopsis: Splits forms across multiple Web pages.
-.. versionadded:: 1.0
 Django comes with an optional "form wizard" application that splits
 :ref:`forms <topics-forms-index>` across multiple Web pages. It maintains
 state in hashed HTML :samp:`<input type="hidden">` fields, and the data isn't

docs/ref/contrib/humanize.txt

diff --git a/docs/ref/contrib/humanize.txt b/docs/ref/contrib/humanize.txt
index 07a62a7..41297b6 100644

                You can pass in either an integer or a string representation of an integer.
 naturalday
 ----------
-.. versionadded:: 1.0
 For dates that are the current day or within one day, return "today",
 "tomorrow" or "yesterday", as appropriate. Otherwise, format the date using
 the passed in format string.

docs/ref/contrib/index.txt

diff --git a/docs/ref/contrib/index.txt b/docs/ref/contrib/index.txt
index 82a8955..3d58191 100644

                See :ref:`topics-auth`.
 comments
 ========
-.. versionchanged:: 1.0
-   The comments application has been rewriten. See :ref:`ref-contrib-comments-upgrade`
-   for information on howto upgrade.
 A simple yet flexible comments system. See :ref:`ref-contrib-comments-index`.
 contenttypes

docs/ref/contrib/sitemaps.txt

diff --git a/docs/ref/contrib/sitemaps.txt b/docs/ref/contrib/sitemaps.txt
index bdfb77c..b4e2797 100644

                each time you call ``save()``.
 Pinging Google via `manage.py`
 ------------------------------
-.. versionadded:: 1.0
 Once the sitemaps application is added to your project, you may also
 ping the Google server's through the command line manage.py interface::

docs/ref/contrib/sites.txt

diff --git a/docs/ref/contrib/sites.txt b/docs/ref/contrib/sites.txt
index 28c8f4d..20823d5 100644

                To do this, you can use the sites framework. A simple example::
 Caching the current ``Site`` object
 ===================================
-.. versionadded:: 1.0
 As the current site is stored in the database, each call to
 ``Site.objects.get_current()`` could result in a database query. But Django is a
 little cleverer than that: on the first request, the current site is cached, and
-…
+               Here's how Django uses the sites framework:
 .. _requestsite-objects:
-.. versionadded:: 1.0
 Some :ref:`django.contrib <ref-contrib-index>` applications take advantage of
 the sites framework but are architected in a way that doesn't *require* the
 sites framework to be installed in your database. (Some people don't want to, or

docs/ref/contrib/syndication.txt

diff --git a/docs/ref/contrib/syndication.txt b/docs/ref/contrib/syndication.txt
index a2ee621..4cb9fb1 100644

                request to the URL :file:`/rss/beats/0613/`:
       :exc:`ObjectDoesNotExist` in :meth:`get_object()` tells Django to produce
       a 404 error for that request.
-      .. versionadded:: 1.0
-         meth:`get_object()` can handle the :file:`/rss/beats/` url.
       The :meth:`get_object()` method also has a chance to handle the
       :file:`/rss/beats/` url. In this case, :data:`bits` will be an
       empty list. In our example, ``len(bits) != 1`` and an

docs/ref/databases.txt

diff --git a/docs/ref/databases.txt b/docs/ref/databases.txt
index 28651a5..0b4fe83 100644

                many-to-many table would be stored in the ``indexes`` tablespace. The ``data``
 field would also generate an index, but no tablespace for it is specified, so
 it would be stored in the model tablespace ``tables`` by default.
-.. versionadded:: 1.0
 Use the :setting:`DEFAULT_TABLESPACE` and :setting:`DEFAULT_INDEX_TABLESPACE`
 settings to specify default values for the db_tablespace options.
 These are useful for setting a tablespace for the built-in Django apps and

docs/ref/django-admin.txt

diff --git a/docs/ref/django-admin.txt b/docs/ref/django-admin.txt
index 9f25b10..98f44c5 100644

                Available subcommands
 cleanup
 -------
-.. versionadded:: 1.0
 Can be run as a cronjob or directly to clean out old data from the database
 (only expired sessions at the moment).
 compilemessages
 ---------------
-.. versionchanged:: 1.0
-   Before 1.0 this was the "bin/compile-messages.py" command.
 Compiles .po files created with ``makemessages`` to .mo files for use with
 the builtin gettext support. See :ref:`topics-i18n`.
-…
+               createsuperuser
 .. django-admin:: createsuperuser
-.. versionadded:: 1.0
 Creates a superuser account (a user who has all permissions). This is
 useful if you need to create an initial superuser account but did not
 do so during ``syncdb``, or if you need to programmatically generate
-…
+               objects will be dumped.
 .. django-admin-option:: --exclude
-.. versionadded:: 1.0
 Exclude a specific application from the applications whose contents is
 output. For example, to specifically exclude the `auth` application from
 the output, you would call::
-…
+               Example usage::
 makemessages
 ------------
-.. versionchanged:: 1.0
-   Before 1.0 this was the ``bin/make-messages.py`` command.
 Runs over the entire source tree of the current directory and pulls out all
 strings marked for translation. It creates (or updates) a message file in the
 conf/locale (in the django tree) or locale (for project and application)
-…
+               Example usage::
 testserver <fixture fixture ...>
 --------------------------------
-.. versionadded:: 1.0
 Runs a Django development server (as in ``runserver``) using data from the
 given fixture(s).

docs/ref/forms/api.txt

diff --git a/docs/ref/forms/api.txt b/docs/ref/forms/api.txt
index 72dfcb6..92e911a 100644

                object::
     >>> f.cleaned_data
     {'cc_myself': True, 'message': u'Hi there', 'sender': u'foo@example.com', 'subject': u'hello'}
-.. versionchanged:: 1.0
-    The ``cleaned_data`` attribute was called ``clean_data`` in earlier releases.
 Note that any text-based field -- such as ``CharField`` or ``EmailField`` --
 always cleans the input into a Unicode string. We'll cover the encoding
 implications later in this document.
-…
+               when printed::
 Binding uploaded files to a form
 --------------------------------
-.. versionadded:: 1.0
 Dealing with forms that have ``FileField`` and ``ImageField`` fields
 is a little more complicated than a normal form.

docs/ref/forms/fields.txt

diff --git a/docs/ref/forms/fields.txt b/docs/ref/forms/fields.txt
index 0656c32..5d6b3fd 100644

                fields. We've specified ``auto_id=False`` to simplify the output::
 ``error_messages``
 ~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. attribute:: Field.error_messages
-…
+               For each field, we describe the default widget used if you don't specify
       the field has ``required=True``.
     * Error message keys: ``required``
-.. versionchanged:: 1.0
-   The empty value for a ``CheckboxInput`` (and hence the standard ``BooleanField``)
-   has changed to return ``False`` instead of ``None`` in the development version.
 .. note::
     Since all ``Field`` subclasses have ``required=True`` by default, the
-…
+               If no ``input_formats`` argument is provided, the default input formats are::
     '%m/%d/%y %H:%M',        # '10/25/06 14:30'
     '%m/%d/%y',              # '10/25/06'
-.. versionchanged:: 1.0
-   The ``DateTimeField`` used to use a ``TextInput`` widget by default. This has now changed.
 ``DecimalField``
 ~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. class:: DecimalField(**kwargs)
     * Default widget: ``TextInput``
-…
+               given length.
 ``FileField``
 ~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. class:: FileField(**kwargs)
     * Default widget: ``FileInput``
-…
+               When you use a ``FileField`` in a form, you must also remember to
 ``FilePathField``
 ~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. class:: FilePathField(**kwargs)
     * Default widget: ``Select``
-…
+               These control the range of values permitted in the field.
 ``ImageField``
 ~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. class:: ImageField(**kwargs)
     * Default widget: ``FileInput``

docs/ref/forms/widgets.txt

diff --git a/docs/ref/forms/widgets.txt b/docs/ref/forms/widgets.txt
index c9cc292..e9a55c9 100644

                commonly used groups of widgets:
 .. class:: DateTimeInput
-    .. versionadded:: 1.0
     Date/time input as a simple text box: ``<input type='text' ...>``
 .. class:: Textarea

docs/ref/generic-views.txt

diff --git a/docs/ref/generic-views.txt b/docs/ref/generic-views.txt
index f92674e..b78feb4 100644

                a date in the *future* are not included unless you set ``allow_future`` to
       specified in ``date_field`` is greater than the current date/time. By
       default, this is ``False``.
-    .. versionadded:: 1.0
     * ``template_object_name``: Designates the name of the template variable
       to use in the template context. By default, this is ``'latest'``.
-…
+               In addition to ``extra_context``, the template's context will be:
       ordered in reverse. This is equivalent to
       ``queryset.dates(date_field, 'year')[::-1]``.
-    .. versionchanged:: 1.0
-       The behaviour depending on ``template_object_name`` is new in this version.
     * ``latest``: The ``num_latest`` objects in the system, ordered descending
       by ``date_field``. For example, if ``num_latest`` is ``10``, then
       ``latest`` will be a list of the latest 10 objects in ``queryset``.
-…
+               If ``template_name`` isn't specified, this view will use the template
 **Template context:**
-.. versionadded:: 1.0
-   The ``paginator`` and ``page_obj`` context variables are new.
 In addition to ``extra_context``, the template's context will be:
     * ``object_list``: The list of objects. This variable's name depends on the
-…
+               represented as page ``1``.
 For more on pagination, read the :ref:`pagination documentation
 <topics-pagination>`.
-.. versionadded:: 1.0
 As a special case, you are also permitted to use ``last`` as a value for
 ``page``::
-…
+               Create/update/delete generic views
 The ``django.views.generic.create_update`` module contains a set of functions
 for creating, editing and deleting objects.
-.. versionchanged:: 1.0
-``django.views.generic.create_update.create_object`` and
-``django.views.generic.create_update.update_object`` now use the new :ref:`forms
-library <topics-forms-index>` to build and display the form.
 ``django.views.generic.create_update.create_object``
 ----------------------------------------------------

docs/ref/middleware.txt

diff --git a/docs/ref/middleware.txt b/docs/ref/middleware.txt
index e47accc..40ee983 100644

                Adds a few conveniences for perfectionists:
       don't have a valid URL pattern for ``foo.com/bar`` but *do* have a valid
       pattern for ``foo.com/bar/``.
-      .. versionchanged:: 1.0
-         The behavior of :setting:`APPEND_SLASH` has changed slightly in this
-         version. It didn't used to check whether the pattern was matched in
-         the URLconf.
       If :setting:`PREPEND_WWW` is ``True``, URLs that lack a leading "www."
       will be redirected to the same URL with a leading "www."
-…
+               CSRF protection middleware
 .. class:: django.contrib.csrf.middleware.CsrfMiddleware
-.. versionadded:: 1.0
 Adds protection against Cross Site Request Forgeries by adding hidden form
 fields to POST forms and checking requests for the correct value. See the
 :ref:`Cross Site Request Forgery protection documentation <ref-contrib-csrf>`.

docs/ref/models/fields.txt

diff --git a/docs/ref/models/fields.txt b/docs/ref/models/fields.txt
index 9c5fd23..a32de04 100644

                If ``True``, djadmin:`django-admin.py sqlindexes <sqlindexes>` will output a
 .. attribute:: Field.db_tablespace
-.. versionadded:: 1.0
 The name of the database tablespace to use for this field's index, if this field
 is indexed. The default is the project's :setting:`DEFAULT_INDEX_TABLESPACE`
 setting, if set, or the :attr:`~Field.db_tablespace` of the model, if any. If
-…
+               shortcuts.
 ``DecimalField``
 ----------------
-.. versionadded:: 1.0
 .. class:: DecimalField(max_digits=None, decimal_places=None, [**options])
 A fixed-precision decimal number, represented in Python by a
-…
+               A file-upload field. Has one **required** argument:
     date/time of the file upload (so that uploaded files don't fill up the given
     directory).
-    .. versionchanged:: 1.0
     This may also be a callable, such as a function, which will be called to
     obtain the upload path, including the filename. This callable must be able
     to accept two arguments, and return a Unix-style path (with forward slashes)
-…
+               Also has one optional argument:
 .. attribute:: FileField.storage
-    .. versionadded:: 1.0
     Optional. A storage object, which handles the storage and retrieval of your
     files. See :ref:`topics-files` for details on how to provide this object.
-…
+               without validation, to a directory that's within your Web server's document
 root, then somebody could upload a CGI or PHP script and execute that script by
 visiting its URL on your site. Don't allow that.
-.. versionadded:: 1.0
-   The ``max_length`` argument was added in this version.
 By default, :class:`FileField` instances are
 created as ``varchar(100)`` columns in your database. As with other fields, you
 can change the maximum length using the :attr:`~CharField.max_length` argument.
-…
+               base filename, not the full path. So, this example::
 because the :attr:`~FilePathField.match` applies to the base filename
 (``foo.gif`` and ``bar.gif``).
-.. versionadded:: 1.0
-   The ``max_length`` argument was added in this version.
 By default, :class:`FilePathField` instances are
 created as ``varchar(100)`` columns in your database. As with other fields, you
 can change the maximum length using the :attr:`~CharField.max_length` argument.
-…
+               can change the maximum length using the :attr:`~CharField.max_length` argument.
 .. class:: FloatField([**options])
-.. versionchanged:: 1.0
 A floating-point number represented in Python by a ``float`` instance.
 The admin represents this as an ``<input type="text">`` (a single-line input).
-…
+               Requires the `Python Imaging Library`_.
 .. _Python Imaging Library: http://www.pythonware.com/products/pil/
-.. versionadded:: 1.0
-   The ``max_length`` argument was added in this version.
 By default, :class:`ImageField` instances are
 created as ``varchar(100)`` columns in your database. As with other fields, you
 can change the maximum length using the :attr:`~CharField.max_length` argument.
-…
+               Note, however, that this only refers to models in the same ``models.py`` file --
 you cannot use a string to reference a model defined in another application or
 imported from elsewhere.
-.. versionchanged:: 1.0
-   Refering models in other applications must include the application label.
 To refer to models defined in another
 application, you must instead explicitly specify the application label. For
 example, if the ``Manufacturer`` model above is defined in another application

docs/ref/models/instances.txt

diff --git a/docs/ref/models/instances.txt b/docs/ref/models/instances.txt
index c7ea4f3..9c6e0f2 100644

                To save an object back to the database, call ``save()``:
 Of course, there are some subtleties; see the sections below.
-.. versionadded:: 1.0
-The signature of the ``save()`` method has changed from earlier versions
-(``force_insert`` and ``force_update`` have been added). If you are overriding
-these methods, be sure to use the correct signature.
 Auto-incrementing primary keys
 ------------------------------
-…
+               documentation for ``AutoField`` for more details.
 The ``pk`` property
 ~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. attribute:: Model.pk
 Regardless of whether you define a primary key field yourself, or let Django
-…
+               auto-primary-key values`_ above and `Forcing an INSERT or UPDATE`_ below.
 Forcing an INSERT or UPDATE
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 In some rare circumstances, it's necessary to be able to force the ``save()``
 method to perform an SQL ``INSERT`` and not fall back to doing an ``UPDATE``.
 Or vice-versa: update, if possible, but not insert a new row. In these cases

docs/ref/models/options.txt

diff --git a/docs/ref/models/options.txt b/docs/ref/models/options.txt
index e4e2d38..8e5f39b 100644

                Django quotes column and table names behind the scenes.
 .. attribute:: Options.db_tablespace
-.. versionadded:: 1.0
 The name of the database tablespace to use for the model. If the backend doesn't
 support tablespaces, this option is ignored.
-…
+               It's used in the Django admin and is enforced at the database level (i.e., the
 appropriate ``UNIQUE`` statements are included in the ``CREATE TABLE``
 statement).
-.. versionadded:: 1.0
 For convenience, unique_together can be a single list when dealing with a single
 set of fields::

docs/ref/models/querysets.txt

diff --git a/docs/ref/models/querysets.txt b/docs/ref/models/querysets.txt
index 68b69b6..010b683 100644

                ordering piece of data for each of the main items you are selecting, the
 ordering may well be exactly what you want to do. Use ordering on multi-valued
 fields with care and make sure the results are what you expect.
-.. versionadded:: 1.0
 If you don't want any ordering to be applied to a query, not even the default
 ordering, call ``order_by()`` with no parameters.
-.. versionadded:: 1.0
 The syntax for ordering across related models has changed. See the `Django 0.96
 documentation`_ for the old behaviour.
-…
+               A couple of subtleties that are worth mentioning:
         >>> Entry.objects.values('blog_id')
         [{'blog_id': 1}, ...]
     * When using ``values()`` together with ``distinct()``, be aware that
       ordering can affect the results. See the note in the `distinct()`_
       section, above, for details.
-.. versionadded:: 1.0
-Previously, it was not possible to pass ``blog_id`` to ``values()`` in the above
-example, only ``blog``.
 A ``ValuesQuerySet`` is useful when you know you're only going to need values
 from a small number of the available fields and you won't need the
 functionality of a model instance object. It's more efficient to select only
-…
+               individualism.
 ``values_list(*fields)``
 ~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 This is similar to ``values()`` except that instead of returning a list of
 dictionaries, it returns a list of tuples. Each tuple contains the value from
 the respective field passed into the ``values_list()`` call -- so the first
-…
+               Examples::
 ``none()``
 ~~~~~~~~~~
-.. versionadded:: 1.0
 Returns an ``EmptyQuerySet`` -- a ``QuerySet`` that always evaluates to
 an empty list. This can be used in cases where you know that you should
 return an empty result set and your caller is expecting a ``QuerySet``
-…
+               follow::
     p = b.author         # Doesn't hit the database.
     c = p.hometown       # Requires a database call.
-.. versionadded:: 1.0
-The ``depth`` argument is new in Django version 1.0.
 ``extra(select=None, where=None, params=None, tables=None, order_by=None, select_params=None)``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-…
+               of the arguments is required, but you should use at least one of them.
     some database backends, such as some MySQL versions, don't support
     subqueries.
-    .. versionadded:: 1.0
     In some rare cases, you might wish to pass parameters to the SQL fragments
     in ``extra(select=...)```. For this purpose, use the ``select_params``
     parameter. Since ``select_params`` is a sequence and the ``select``
-…
+               SQL equivalents::
     SELECT ... WHERE id = 14;
     SELECT ... WHERE id IS NULL;
-.. versionchanged:: 1.0
-   The semantics of ``id__exact=None`` have
-   changed in the development version. Previously, it was (intentionally)
-   converted to ``WHERE id = NULL`` at the SQL level, which would never match
-   anything. It has now been changed to behave the same as ``id__isnull=True``.
 .. admonition:: MySQL comparisons
     In MySQL, whether or not ``exact`` comparisons are case-insensitive by
-…
+               database to add the full-text index.
 regex
 ~~~~~
-.. versionadded:: 1.0
 Case-sensitive regular expression match.
 The regular expression syntax is that of the database backend in use. In the
-…
+               regular expression syntax is recommended.
 iregex
 ~~~~~~
-.. versionadded:: 1.0
 Case-insensitive regular expression match.
 Example::

docs/ref/request-response.txt

diff --git a/docs/ref/request-response.txt b/docs/ref/request-response.txt
index 89e5195..2805280 100644

                All attributes except ``session`` should be considered read-only.
 .. attribute:: HttpRequest.encoding
-    .. versionadded:: 1.0
     A string representing the current encoding used to decode form submission
     data (or ``None``, which means the ``DEFAULT_CHARSET`` setting is used).
     You can write to this attribute to change the encoding used when accessing
-…
+               All attributes except ``session`` should be considered read-only.
     ``enctype="multipart/form-data"``. Otherwise, ``FILES`` will be a blank
     dictionary-like object.
-    .. versionchanged:: 1.0
     In previous versions of Django, ``request.FILES`` contained simple ``dict``
     objects representing uploaded files. This is no longer true -- files are
     represented by ``UploadedFile`` objects as described below.
-…
+               Methods
 .. method:: HttpRequest.get_host()
-   .. versionadded:: 1.0
    Returns the originating host of the request using information from the
    ``HTTP_X_FORWARDED_HOST`` and ``HTTP_HOST`` headers (in that order). If
    they don't provide a value, the method uses a combination of
-…
+               Methods
 .. method:: HttpRequest.build_absolute_uri(location)
-   .. versionadded:: 1.0
    Returns the absolute URI form of ``location``. If no location is provided,
    the location will be set to ``request.get_full_path()``.
-…
+               Methods
 .. method:: HttpRequest.is_ajax()
-   .. versionadded:: 1.0
    Returns ``True`` if the request was made via an ``XMLHttpRequest``, by checking
    the ``HTTP_X_REQUESTED_WITH`` header for the string ``'XMLHttpRequest'``. The
    following major JavaScript libraries all send this header:
-…
+               In addition, ``QueryDict`` has the following methods:
 .. method:: QueryDict.lists()
     Like :method:items(), except it includes all values, as a list, for each
+    Like :meth:`items()`, except it includes all values, as a list, for each
     member of the dictionary. For example::
          >>> q = QueryDict('a=1&a=2&a=3')
-…
+               Methods
     ``status`` is the `HTTP Status code`_ for the response.
-    .. versionadded:: 1.0
     ``content_type`` is an alias for ``mimetype``. Historically, this parameter
     was only called ``mimetype``, but since this is actually the value included
     in the HTTP ``Content-Type`` header, it can also include the character set
-…
+               types of HTTP responses. Like ``HttpResponse``, these subclasses live in
 .. class:: HttpResponseBadRequest
-    .. versionadded:: 1.0
     Acts just like :class:`HttpResponse` but uses a 400 status code.
 .. class:: HttpResponseNotFound

docs/ref/settings.txt

diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
index 3dd83eb..d2deb95 100644

                Never deploy a site into production with ``DEBUG`` turned on.
 DEBUG_PROPAGATE_EXCEPTIONS
 --------------------------
-.. versionadded:: 1.0
 Default: ``False``
 If set to True, Django's normal exception handling of view functions
-…
+               site manager(s).
 DEFAULT_TABLESPACE
 ------------------
-.. versionadded:: 1.0
 Default: ``''`` (Empty string)
 Default tablespace to use for models that don't specify one, if the
-…
+               backend supports it.
 DEFAULT_INDEX_TABLESPACE
 ------------------------
-.. versionadded:: 1.0
 Default: ``''`` (Empty string)
 Default tablespace to use for indexes on fields that don't specify
-…
+               trailing space.
 EMAIL_USE_TLS
 -------------
-.. versionadded:: 1.0
 Default: ``False``
 Whether to use a TLS (secure) connection when talking to the SMTP server.
-…
+               Whether to use a TLS (secure) connection when talking to the SMTP server.
 FILE_CHARSET
 ------------
-.. versionadded:: 1.0
 Default: ``'utf-8'``
 The character encoding used to decode any files read from disk. This includes
-…
+               template files and initial SQL data files.
 FILE_UPLOAD_HANDLERS
 --------------------
-.. versionadded:: 1.0
 Default::
     ("django.core.files.uploadhandler.MemoryFileUploadHandler",
-…
+               A tuple of handlers to use for uploading. See :ref:`topics-files` for details.
 FILE_UPLOAD_MAX_MEMORY_SIZE
 ---------------------------
-.. versionadded:: 1.0
 Default: ``2621440`` (i.e. 2.5 MB).
 The maximum size (in bytes) that an upload will be before it gets streamed to
-…
+               the file system. See :ref:`topics-files` for details.
 FILE_UPLOAD_TEMP_DIR
 --------------------
-.. versionadded:: 1.0
 Default: ``None``
 The directory to store data temporarily while uploading files. If ``None``,
-…
+               standard language format. For example, U.S. English is ``"en-us"``. See
 LANGUAGE_COOKIE_NAME
 --------------------
-.. versionadded:: 1.0
 Default: ``'django_language'``
 The name of the cookie to use for the language cookie. This can be whatever you
-…
+               See :ref:`translations-in-your-own-projects`.
 LOGIN_REDIRECT_URL
 ------------------
-.. versionadded:: 1.0
 Default: ``'/accounts/profile/'``
 The URL where requests are redirected after login when the
-…
+               decorator, for example.
 LOGIN_URL
 ---------
-.. versionadded:: 1.0
 Default: ``'/accounts/login/'``
 The URL where requests are redirected for login, specially when using the
-…
+               The URL where requests are redirected for login, specially when using the
 LOGOUT_URL
 ----------
-.. versionadded:: 1.0
 Default: ``'/accounts/logout/'``
 LOGIN_URL counterpart.
-…
+               The e-mail address that error messages come from, such as those sent to
 SESSION_ENGINE
 --------------
-.. versionadded:: 1.0
 Default: ``django.contrib.sessions.backends.db``
 Controls where Django stores session data. Valid values are:
-…
+               should be different from ``LANGUAGE_COOKIE_NAME``). See the :ref:`topics-http-se
 SESSION_COOKIE_PATH
 -------------------
-.. versionadded:: 1.0
 Default: ``'/'``
 The path set on the session cookie. This should either match the URL path of your
-…
+               See the :ref:`topics-http-sessions`.
 SESSION_FILE_PATH
 -----------------
-.. versionadded:: 1.0
 Default: ``None``
 If you're using file-based session storage, this sets the directory in
-…
+               misspelled) variables. See :ref:`invalid-template-variables`..
 TEST_DATABASE_CHARSET
 ---------------------
-.. versionadded:: 1.0
 Default: ``None``
 The character set encoding used to create the test database. The value of this
-…
+               Supported for the PostgreSQL_ (``postgresql``, ``postgresql_psycopg2``) and MySQ
 TEST_DATABASE_COLLATION
 ------------------------
-.. versionadded:: 1.0
 Default: ``None``
 The collation order to use when creating the test database. This value is

docs/ref/templates/api.txt

diff --git a/docs/ref/templates/api.txt b/docs/ref/templates/api.txt
index a220c79..df9e932 100644

                See :ref:`topics-i18n` for more.
 django.core.context_processors.media
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 If :setting:`TEMPLATE_CONTEXT_PROCESSORS` contains this processor, every
 ``RequestContext`` will contain a variable ``MEDIA_URL``, providing the
 value of the :setting:`MEDIA_URL` setting.

docs/ref/templates/builtins.txt

diff --git a/docs/ref/templates/builtins.txt b/docs/ref/templates/builtins.txt
index a28cf4f..b3835fb 100644

                Built-in tag reference
 autoescape
 ~~~~~~~~~~
-.. versionadded:: 1.0
 Control the current auto-escaping behavior. This tag takes either ``on`` or
 ``off`` as an argument and that determines whether auto-escaping is in effect
 inside the block.
-…
+               Ignore everything between ``{% comment %}`` and ``{% endcomment %}``
 cycle
 ~~~~~
-.. versionchanged:: 1.0
-    Cycle among the given strings or variables each time this tag is encountered.
 Within a loop, cycles among the given strings/variables each time through the
 loop::
-…
+               provided in ``athlete_list``::
 You can loop over a list in reverse by using ``{% for obj in list reversed %}``.
-.. versionadded:: 1.0
 If you need to loop over a list of lists, you can unpack the values
 in each sub-list into individual variables. For example, if your context
 contains a list of (x,y) coordinates called ``points``, you could use the
-…
+               such as this:
 The template tag will output the string ``/clients/client/123/``.
-.. versionadded:: 1.0
 If you're using :ref:`named URL patterns <naming-url-patterns>`, you can
 refer to the name of the pattern in the ``url`` tag instead of using the
 path to the view.
-…
+               Note that if the URL you're reversing doesn't exist, you'll get an
 :exc:`NoReverseMatch` exception raised, which will cause your site to display an
 error page.
-.. versionadded:: 1.0
 If you'd like to retrieve a URL without displaying it, you can use a slightly
 different call::
-…
+               which is rounded up to 88).
 with
 ~~~~
-.. versionadded:: 1.0
 Caches a complex variable under a simpler name. This is useful when accessing
 an "expensive" method (e.g., one that hits the database) multiple times.
-…
+               applied to the result will only result in one round of escaping being done. So
 it is safe to use this function even in auto-escaping environments. If you want
 multiple escaping passes to be applied, use the ``force_escape`` filter.
-.. versionchanged:: 1.0
-    Due to auto-escaping, the behavior of this filter has changed slightly.
-    The replacements are only made once, after
-    all other filters are applied -- including filters before and after it.
 .. templatefilter:: escapejs
 escapejs
 ~~~~~~~~
-.. versionadded:: 1.0
 Escapes characters for use in JavaScript strings. This does *not* make the
 string safe for use in HTML, but does protect you from syntax errors when using
 templates to generate JavaScript/JSON.
-…
+               If ``value`` is the list ``['a', 'b', 'c']``, the output will be ``'a'``.
 fix_ampersands
 ~~~~~~~~~~~~~~
-.. versionchanged:: 1.0
-    This is rarely useful as ampersands are now automatically escaped. See escape_ for more information.
 Replaces ampersands with ``&amp;`` entities.
 For example::
-…
+               with an argument of ``-1``.
 force_escape
 ~~~~~~~~~~~~
-.. versionadded:: 1.0
 Applies HTML escaping to a string (see the ``escape`` filter for details).
 This filter is applied *immediately* and returns a new, escaped string. This
 is useful in the rare cases where you need multiple escaping or want to apply
-…
+               If ``value`` is the list ``['a', 'b', 'c']``, the output will be the string
 last
 ~~~~
-.. versionadded:: 1.0
 Returns the last item in a list.
 For example::
-…
+               unordered_list
 Recursively takes a self-nested list and returns an HTML unordered list --
 WITHOUT opening and closing <ul> tags.
-.. versionchanged:: 1.0
-   The format accepted by ``unordered_list`` has changed to be easier to understand.
 The list is assumed to be in the proper format. For example, if ``var`` contains
 ``['States', ['Kansas', ['Lawrence', 'Topeka'], 'Illinois']]``, then
 ``{{ var|unordered_list }}`` would return::

docs/ref/unicode.txt

diff --git a/docs/ref/unicode.txt b/docs/ref/unicode.txt
index 4976a35..16d2cc8 100644

-              a
 Unicode data in Django
 ======================
-.. versionadded:: 1.0
 Django natively supports Unicode data everywhere. Providing your database can
 somehow store the data, you can safely pass around Unicode strings to
 templates, models and the database.

docs/topics/auth.txt

diff --git a/docs/topics/auth.txt b/docs/topics/auth.txt
index b6e9a9d..9d454ec 100644

                Methods
     .. method:: models.User.set_unusable_password()
-        .. versionadded:: 1.0
         Marks the user as having no password set.  This isn't the same as having
         a blank string for a password.
         :meth:`~django.contrib.auth.models.User.check_password()` for this user
-…
+               Methods
     .. method:: models.User.has_usable_password()
-        .. versionadded:: 1.0
         Returns ``False`` if
         :meth:`~django.contrib.auth.models.User.set_unusable_password()` has
         been called for this user.
-…
+               they're used by Web requests, as explained in the next section.
 Creating superusers
 -------------------
-.. versionadded:: 1.0
-   The ``manage.py createsuperuser`` command is new.
 :djadmin:`manage.py syncdb <syncdb>` prompts you to create a superuser the first time
 you run it after adding ``'django.contrib.auth'`` to your
 :setting:`INSTALLED_APPS`. If you need to create a superuser at a later date,
-…
+               How to log a user out
     Note that :func:`~django.contrib.auth.logout()` doesn't throw any errors
     if the user wasn't logged in.
-    .. versionchanged:: 1.0
-       Calling ``logout()`` now cleans session data.
     When you call :func:`~django.contrib.auth.logout()`, the session
     data for the current request is completely cleaned out. All existing data
     is removed. This is to prevent another person from using the same web

docs/topics/cache.txt

diff --git a/docs/topics/cache.txt b/docs/topics/cache.txt
index 4f32627..d77e36c 100644

                production environment still will. To activate dummy caching, set
 Using a custom cache backend
 ----------------------------
-.. versionadded:: 1.0
 While Django includes support for a number of cache backends out-of-the-box,
 sometimes you might want to use a customized cache backend. To use an external
 cache backend with Django, use a Python import path as the scheme portion (the
-…
+               arguments.
 The per-site cache
 ==================
-.. versionchanged:: 1.0
-    (previous versions of Django only provided a single ``CacheMiddleware`` instead
-    of the two pieces described below).
 Once the cache is set up, the simplest way to use caching is to cache your
 entire site. You'll need to add
 ``'django.middleware.cache.UpdateCacheMiddleware'`` and
-…
+               Additionally, the cache middleware automatically sets a few headers in each
 See :ref:`topics-http-middleware` for more on middleware.
-.. versionadded:: 1.0
 If a view sets its own cache expiry time (i.e. it has a ``max-age`` section in
 its ``Cache-Control`` header) then the page will be cached until the expiry
 time, rather than ``CACHE_MIDDLEWARE_SECONDS``. Using the decorators in
-…
+               minutes.
 Template fragment caching
 =========================
-.. versionadded:: 1.0
 If you're after even more control, you can also cache template fragments using
 the ``cache`` template tag. To give your template access to this tag, put
 ``{% load cache %}`` near the top of your template.
-…
+               get() can take a ``default`` argument::
     >>> cache.get('my_key', 'has expired')
     'has expired'
-.. versionadded:: 1.0
 To add a key only if it doesn't already exist, use the ``add()`` method.
 It takes the same parameters as ``set()``, but it will not attempt to
 update the cache if the key specified is already present::

docs/topics/db/models.txt

diff --git a/docs/topics/db/models.txt b/docs/topics/db/models.txt
index a655c4e..3600425 100644

                work; all are optional.
 Extra fields on many-to-many relationships
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 When you're only dealing with simple many-to-many relationships such as
 mixing and matching pizzas and toppings, a standard :class:`~django.db.models.ManyToManyField` is all you need. However, sometimes
 you may need to associate data with the relationship between two models.
-…
+               can be made; see :ref:`the model field reference <ref-onetoone>` for details.
 .. _One-to-one relationship model example: http://www.djangoproject.com/documentation/models/one_to_one/
-.. versionadded:: 1.0
 :class:`~django.db.models.OneToOneField` fields also accept one optional argument
 described in the :ref:`model field reference <ref-onetoone>`.
-…
+               particular database engine.
 Custom field types
 ------------------
-.. versionadded:: 1.0
 If one of the existing model fields cannot be used to fit your purposes, or if
 you wish to take advantage of some less common database column types, you can
 create your own field class. Full coverage of creating your own fields is
-…
+               query.
 Model inheritance
 =================
-.. versionadded:: 1.0
 Model inheritance in Django works almost identically to the way normal
 class inheritance works in Python. The only decision you have to make
 is whether you want the parent models to be models in their own right

docs/topics/db/queries.txt

diff --git a/docs/topics/db/queries.txt b/docs/topics/db/queries.txt
index 1460fb2..98d1a36 100644

                those latter objects, you could write::
 Spanning multi-valued relationships
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 When you are filtering an object based on a ``ManyToManyField`` or a reverse
 ``ForeignKeyField``, there are two different sorts of filter you may be
 interested in. Consider the ``Blog``/``Entry`` relationship (``Blog`` to
-…
+               complete query set::
 Updating multiple objects at once
 =================================
-.. versionadded:: 1.0
 Sometimes you want to set a field to a particular value for all the objects in
 a ``QuerySet``. You can do this with the ``update()`` method. For example::
-…
+               standpoint. For instructions, see :ref:`topics-db-sql`.
 Finally, it's important to note that the Django database layer is merely an
 interface to your database. You can access your database via other tools,
 programming languages or database frameworks; there's nothing Django-specific
+about your database.
+ No newline at end of file
+about your database.

docs/topics/email.txt

diff --git a/docs/topics/email.txt b/docs/topics/email.txt
index 2521385..875cc70 100644

                from the request's POST data, sends that to admin@example.com and redirects to
 The EmailMessage and SMTPConnection classes
 ===========================================
-.. versionadded:: 1.0
 Django's ``send_mail()`` and ``send_mass_mail()`` functions are actually thin
 wrappers that make use of the ``EmailMessage`` and ``SMTPConnection`` classes
 in ``django.core.mail``.  If you ever need to customize the way Django sends

docs/topics/files.txt

diff --git a/docs/topics/files.txt b/docs/topics/files.txt
index f4cb672..5a4d07e 100644

-              a
 Managing files
 ==============
-.. versionadded:: 1.0
 This document describes Django's file access APIs.
 By default, Django stores files locally, using the :setting:`MEDIA_ROOT` and

docs/topics/forms/index.txt

diff --git a/docs/topics/forms/index.txt b/docs/topics/forms/index.txt
index 5cc76bd..846233f 100644

                There are three code paths here:
 . If the form has been submitted but is invalid, the bound form instance is
        passed on to the template.
-.. versionchanged:: 1.0
-    The ``cleaned_data`` attribute was called ``clean_data`` in earlier releases.
 The distinction between **bound** and **unbound** forms is important. An unbound
 form does not have any data associated with it; when rendered to the user, it
 will be empty or will contain default values. A bound form does have submitted

docs/topics/http/file-uploads.txt

diff --git a/docs/topics/http/file-uploads.txt b/docs/topics/http/file-uploads.txt
index 24ff0eb..6875d11 100644

                File Uploads
 .. currentmodule:: django.core.files
-.. versionadded:: 1.0
 Most Web sites wouldn't be complete without a way to upload files. When Django
 handles a file upload, the file data ends up placed in ``request.FILES`` (for
 more on the ``request`` object see the documentation for :ref:`request and

docs/topics/http/sessions.txt

diff --git a/docs/topics/http/sessions.txt b/docs/topics/http/sessions.txt
index 81d4917..9818fa5 100644

                To enable session functionality, do the following:
       and run ``manage.py syncdb`` to install the single database table
       that stores session data.
-.. versionchanged:: 1.0
-   This step is optional if you're not using the database session backend;
-   see `configuring the session engine`_.
 If you don't want to use sessions, you might as well remove the
 ``SessionMiddleware`` line from ``MIDDLEWARE_CLASSES`` and ``'django.contrib.sessions'``
 from your ``INSTALLED_APPS``. It'll save you a small bit of overhead.
-…
+               from your ``INSTALLED_APPS``. It'll save you a small bit of overhead.
 Configuring the session engine
 ==============================
-.. versionadded:: 1.0
 By default, Django stores sessions in your database (using the model
 ``django.contrib.sessions.models.Session``). Though this is convenient, in
 some setups it's faster to store session data elsewhere, so Django can be
-…
+               A session object has the following standard dictionary methods:
     * ``clear()``
-.. versionadded:: 1.0
-   ``setdefault()`` and ``clear()`` are new in this version.
 It also has these methods:
     * ``flush()``
-      .. versionadded:: 1.0
       Delete the current session data from the database and regenerate the
       session key value that is sent back to the user in the cookie. This is
       used if you want to ensure that the previous session data can't be
-…
+               It also has these methods:
     * ``set_expiry(value)``
-      .. versionadded:: 1.0
       Sets the expiration time for the session. You can pass a number of
       different values:
-…
+               It also has these methods:
     * ``get_expiry_age()``
-      .. versionadded:: 1.0
       Returns the number of seconds until this session expires. For sessions
       with no custom expiration (or those set to expire at browser close), this
       will equal ``settings.SESSION_COOKIE_AGE``.
     * ``get_expiry_date()``
-      .. versionadded:: 1.0
       Returns the date this session will expire. For sessions with no custom
       expiration (or those set to expire at browser close), this will equal the
       date ``settings.SESSION_COOKIE_AGE`` seconds from now.
     * ``get_expire_at_browser_close()``
-      .. versionadded:: 1.0
       Returns either ``True`` or ``False``, depending on whether the user's
       session cookie will expire when the user's Web browser is closed.
-…
+               Here's a typical usage example::
 Using sessions out of views
 ===========================
-.. versionadded:: 1.0
 An API is available to manipulate session data outside of a view::
     >>> from django.contrib.sessions.backends.db import SessionStore
-…
+               browser-length cookies -- cookies that expire as soon as the user closes his or
 her browser. Use this if you want people to have to log in every time they open
 a browser.
-.. versionadded:: 1.0
 This setting is a global default and can be overwritten at a per-session level
 by explicitly calling ``request.session.set_expiry()`` as described above in
 `using sessions in views`_.
-…
+               A few :ref:`Django settings <ref-settings>` give you control over session behavi
 SESSION_ENGINE
 --------------
-.. versionadded:: 1.0
 Default: ``django.contrib.sessions.backends.db``
 Controls where Django stores session data. Valid values are:
-…
+               See `configuring the session engine`_ for more details.
 SESSION_FILE_PATH
 -----------------
-.. versionadded:: 1.0
 Default: ``/tmp/``
 If you're using file-based session storage, this sets the directory in

docs/topics/http/shortcuts.txt

diff --git a/docs/topics/http/shortcuts.txt b/docs/topics/http/shortcuts.txt
index b60ccdd..b02dcc3 100644

                Optional arguments
 ``mimetype``
-    .. versionadded:: 1.0
     The MIME type to use for the resulting document. Defaults to the value of
     the :setting:`DEFAULT_CONTENT_TYPE` setting.

docs/topics/http/urls.txt

diff --git a/docs/topics/http/urls.txt b/docs/topics/http/urls.txt
index db9a348..3845bd0 100644

                The remaining arguments should be tuples in this format::
 url
 ---
-.. versionadded:: 1.0
 You can use the ``url()`` function, instead of a tuple, as an argument to
 ``patterns()``. This is convenient if you want to specify a name without the
 optional extra arguments dictionary. For example::
-…
+               the view prefix (as explained in "The view prefix" above) will have no effect.
 Naming URL patterns
 ===================
-.. versionadded:: 1.0
 It's fairly common to use the same view function in multiple URL patterns in
 your URLconf. For example, these two URL patterns both point to the ``archive``
 view::

docs/topics/i18n.txt

diff --git a/docs/topics/i18n.txt b/docs/topics/i18n.txt
index 8ba2f9c..36d7859 100644

                following this algorithm:
     * Failing that, it looks for a cookie.
-      .. versionchanged:: 1.0
       In Django version 0.96 and before, the cookie's name is hard-coded to
       ``django_language``. In Django 1,0, The cookie name is set by the
       ``LANGUAGE_COOKIE_NAME`` setting. (The default name is

docs/topics/pagination.txt

diff --git a/docs/topics/pagination.txt b/docs/topics/pagination.txt
index 455f62a..e30c5b6 100644

                Pagination
 .. module:: django.core.paginator
    :synopsis: Classes to help you easily manage paginated data.
-.. versionchanged:: 1.0
-   Pagination facilities have been almost fully reworked.
 Django provides a few classes that help you manage paginated data -- that is,
 data that's split across several pages, with "Previous/Next" links. These
 classes live in :file:`django/core/paginator.py`.

docs/topics/templates.txt

diff --git a/docs/topics/templates.txt b/docs/topics/templates.txt
index 66361c8..e0ac9ba 100644

                wouldn't know which one of the blocks' content to use.
 Automatic HTML escaping
 =======================
-.. versionadded:: 1.0
 When generating HTML from templates, there's always a risk that a variable will
 include characters that affect the resulting HTML. For example, consider this
 template fragment::
-…
+               template (e.g., one that has ``{% extends "foo.html" %}``) will *not* have
 access to the comments template tags and filters. The child template is
 responsible for its own ``{% load comments %}``.
+This is a feature for the sake of maintainability and sanity.
+ No newline at end of file
+This is a feature for the sake of maintainability and sanity.

docs/topics/testing.txt

diff --git a/docs/topics/testing.txt b/docs/topics/testing.txt
index 0916f52..bc8f7f0 100644

                with this command::
 Note that we used ``animals``, not ``myproject.animals``.
-.. versionadded:: 1.0
-   You can now choose which test to run.
 If you use unit tests, as opposed to
 doctests, you can be even *more* specific in choosing which tests to execute.
 To run a single test case in an application (for example, the
-…
+               etc. The test database is created by the user specified by
 :setting:`DATABASE_USER`, so you'll need to make sure that the given user
 account has sufficient privileges to create a new database on the system.
-.. versionadded:: 1.0
 For fine-grained control over the
 character encoding of your test database, use the
 :setting:`TEST_DATABASE_CHARSET` setting. If you're using MySQL, you can also
-…
+               arguments at time of construction:
     .. method:: Client.login(**credentials)
-        .. versionadded:: 1.0
         If your site uses Django's :ref:`authentication system<topics-auth>`
         and you deal with logging in users, you can use the test client's
         ``login()`` method to simulate the effect of a user logging into the
-…
+               arguments at time of construction:
     .. method:: Client.logout()
-        .. versionadded:: 1.0
         If your site uses Django's :ref:`authentication system<topics-auth>`,
         the ``logout()`` method can be used to simulate the effect of a user
         logging out of your site.
-…
+               additions.
 Default test client
 ~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. attribute:: TestCase.client
 Every test case in a ``django.test.TestCase`` instance has access to an
-…
+               or by the order of test execution.
 URLconf configuration
 ~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 .. attribute:: TestCase.urls
 If your application provides views, you may want to include tests that use the
-…
+               URLconf for the duration of the test case.
 Emptying the test outbox
 ~~~~~~~~~~~~~~~~~~~~~~~~
-.. versionadded:: 1.0
 If you use Django's custom ``TestCase`` class, the test runner will clear the
 contents of the test e-mail outbox at the start of each test case.
-…
+               For more detail on e-mail services during tests, see `E-mail services`_.
 Assertions
 ~~~~~~~~~~
-.. versionadded:: 1.0
 As Python's normal ``unittest.TestCase`` class implements assertion methods
 such as ``assertTrue`` and ``assertEquals``, Django's custom ``TestCase`` class
 provides a number of custom assertion methods that are useful for testing Web
-…
+               applications:
 E-mail services
 ---------------
-.. versionadded:: 1.0
 If any of your Django views send e-mail using :ref:`Django's e-mail
 functionality <topics-email>`, you probably don't want to send e-mail each time
 you run a test using that view. For this reason, Django's test runner
-…
+               that can be executed from Python code.
 Defining a test runner
 ----------------------
-.. versionadded:: 1.0
 .. currentmodule:: django.test.simple
 By convention, a test runner should be called ``run_tests``. The only strict
-…
+               provides some utilities that can be useful during testing.
     ``create_test_db()`` has the side effect of modifying
     ``settings.DATABASE_NAME`` to match the name of the test database.
-    .. versionchanged:: 1.0
-       ``create_test_db()`` now returns the name of the test database.
 .. function:: destroy_test_db(old_database_name, verbosity=1)
     Destroys the database whose name is in the :setting:`DATABASE_NAME` setting

Download in other formats:

Original Format

Issues

Context Navigation

Ticket #8991: django.git-docs-trunk.patch

Download in other formats: