  will have one argument -- the template context as of when the tag was called.
  
  For example, say you're writing an inclusion tag that will always be used in a
  context that contains ``home_link`` and ``home_title`` variables that point
  back to the main page. Here's what the Python function would look like::
  
      # The first argument *must* be called "context" here.
      def jump_link(context):
          return {
              'link': context['home_link'],
 
</s> remove ``takes_context`` argument when registering your tag::
 </s> add ``takes_context`` argument when registering your tag:

.. code-block:: python </s> remove for the template fragment. Example::
 </s> add for the template fragment. Example:

.. code-block:: python </s> remove .. _howto-custom-template-tags-assignment-tags:

Assignment tags
~~~~~~~~~~~~~~~

.. versionadded:: 1.4

Another common type of template tag is the type that fetches some data and
stores it in a context variable. To ease the creation of this type of tags,
Django provides a helper function, ``assignment_tag``. This function works
the same way as :ref:`simple_tag<howto-custom-template-tags-simple-tags>`,
except that it stores the tag's result in a specified context variable instead
of directly outputting it.

Our earlier ``current_time`` function could thus be written like this:

.. code-block:: python

    def get_current_time(format_string):
        return datetime.datetime.now().strftime(format_string)

    register.assignment_tag(get_current_time)

The decorator syntax also works:

.. code-block:: python

    @register.assignment_tag
    def get_current_time(format_string):
        ...

You may then store the result in a template variable using the ``as`` argument
followed by the variable name, and output it yourself where you see fit:

.. code-block:: html+django

    {% get_current_time "%Y-%m-%d %I:%M %p" as the_time %}
    <p>The time is {{ the_time }}.</p>

If your template tag needs to access the current context, you can use the
``takes_context`` argument when registering your tag:

.. code-block:: python

    # The first argument *must* be called "context" here.
    def get_current_time(context, format_string):
        timezone = context['timezone']
        return your_get_current_time_method(timezone, format_string)

    register.assignment_tag(takes_context=True)(get_current_time)

Or, using decorator syntax:

.. code-block:: python

    @register.assignment_tag(takes_context=True)
    def get_current_time(context, format_string):
        timezone = context['timezone']
        return your_get_current_time_method(timezone, format_string)

For more information on how the ``takes_context`` option works, see the section
on :ref:`inclusion tags<howto-custom-template-tags-inclusion-tags>`.

``assignment_tag`` functions may accept any number of positional or keyword
arguments. For example:

.. code-block:: python

    @register.assignment_tag
    def my_tag(a, b, *args, **kwargs):
        warning = kwargs['warning']
        profile = kwargs['profile']
        ...
        return ...

Then in the template any number of arguments, separated by spaces, may be
passed to the template tag. Like in Python, the values for keyword arguments
are set using the equal sign ("``=``") and must be provided after the positional
arguments. For example:

.. code-block:: html+django

    {% my_tag 123 "abcd" book.title warning=message|lower profile=user.profile as the_result %}

 </s> add  </s> remove     Any variable set in the context will only be available in the same ``block``
    of the template in which it was assigned. This behavior is intentional;
    it provides a scope for variables so that they don't conflict with
    context in other blocks.
 </s> add     Any variable set in the context will only be available in the same
    ``block`` of the template in which it was assigned. This behavior is
    intentional; it provides a scope for variables so that they don't conflict
    with context in other blocks. </s> remove pages. Those buttons always look the same, but the link targets change depending
on the object being edited -- so they're a perfect case for using a small
template that is filled with details from the current object. (In the admin's
case, this is the ``submit_row`` tag.)
 </s> add pages. Those buttons always look the same, but the link targets change
depending on the object being edited -- so they're a perfect case for using a
small template that is filled with details from the current object. (In the
admin's case, this is the ``submit_row`` tag.)
back to the main page. Here's what the Python function would look like:

.. code-block:: python
  will have one argument -- the template context as of when the tag was called.
  
  For example, say you're writing an inclusion tag that will always be used in a
  context that contains ``home_link`` and ``home_title`` variables that point
back to the main page. Here's what the Python function would look like:

.. code-block:: python
  
      # The first argument *must* be called "context" here.
      def jump_link(context):
          return {
              'link': context['home_link'],
keep keep keep keep replace keep keep keep keep keep
 Brushed up the custom template tag 'howto' guide by moving the assignment_tag doc to a more appropriate place (i.e. under the "Setting a variable in the context" section), adding cross references, fixing a few minor inaccuracies and doing a little PEP8 cleanup.

git-svn-id: http://code.djangoproject.com/svn/django/trunk@16909 bcc190cf-cafb-0310-a4f2-bffc1f526a37 
docs/howto/custom-template-tags.txt