class NamedUrlCookieWizardView

@classonlymethod
def as_view(cls, *args, **kwargs):
    """
    This method is used within urls.py to create unique wizardview
    instances for every request. We need to override this method because
    we add some kwargs which are needed to make the wizardview usable.
    """
    initkwargs = cls.get_initkwargs(*args, **kwargs)
    return super(WizardView, cls).as_view(**initkwargs)

@classonlymethod
def as_view(cls, **initkwargs):
    """
    Main entry point for a request-response process.
    """
    # sanitize keyword arguments
    for key in initkwargs:
        if key in cls.http_method_names:
            raise TypeError("You tried to pass in the %s method name as a "
                            "keyword argument to %s(). Don't do that."
                            % (key, cls.__name__))
        if not hasattr(cls, key):
            raise TypeError("%s() received an invalid keyword %r. as_view "
                            "only accepts arguments that are already "
                            "attributes of the class." % (cls.__name__, key))
    def view(request, *args, **kwargs):
        self = cls(**initkwargs)
        if hasattr(self, 'get') and not hasattr(self, 'head'):
            self.head = self.get
        self.request = request
        self.args = args
        self.kwargs = kwargs
        return self.dispatch(request, *args, **kwargs)
    # take name and docstring from class
    update_wrapper(view, cls, updated=())
    # and possible attributes set by decorators
    # like csrf_exempt from dispatch
    update_wrapper(view, cls.dispatch, assigned=())
    return view

def dispatch(self, request, *args, **kwargs):
    """
    This method gets called by the routing engine. The first argument is
    `request` which contains a `HttpRequest` instance.
    The request is stored in `self.request` for later use. The storage
    instance is stored in `self.storage`.
    After processing the request using the `dispatch` method, the
    response gets updated by the storage engine (for example add cookies).
    """
    # add the storage engine to the current wizardview instance
    self.prefix = self.get_prefix(*args, **kwargs)
    self.storage = get_storage(self.storage_name, self.prefix, request,
        getattr(self, 'file_storage', None))
    self.steps = StepsHelper(self)
    response = super(WizardView, self).dispatch(request, *args, **kwargs)
    # update the response (e.g. adding cookies)
    self.storage.update_response(response)
    return response

def dispatch(self, request, *args, **kwargs):
    # Try to dispatch to the right method; if a method doesn't exist,
    # defer to the error handler. Also defer to the error handler if the
    # request method isn't on the approved list.
    if request.method.lower() in self.http_method_names:
        handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    else:
        handler = self.http_method_not_allowed
    return handler(request, *args, **kwargs)

def get(self, *args, **kwargs):
    """
    This renders the form or, if needed, does the http redirects.
    """
    step_url = kwargs.get('step', None)
    if step_url is None:
        if 'reset' in self.request.GET:
            self.storage.reset()
            self.storage.current_step = self.steps.first
        if self.request.GET:
            query_string = "?%s" % self.request.GET.urlencode()
        else:
            query_string = ""
        return redirect(self.get_step_url(self.steps.current)
                        + query_string)
    # is the current step the "done" name/view?
    elif step_url == self.done_step_name:
        last_step = self.steps.last
        return self.render_done(self.get_form(step=last_step,
            data=self.storage.get_step_data(last_step),
            files=self.storage.get_step_files(last_step)
        ), **kwargs)
    # is the url step name not equal to the step in the storage?
    # if yes, change the step in the storage (if name exists)
    elif step_url == self.steps.current:
        # URL step name and storage step name are equal, render!
        return self.render(self.get_form(
            data=self.storage.current_step_data,
            files=self.storage.current_step_files,
        ), **kwargs)
    elif step_url in self.get_form_list():
        self.storage.current_step = step_url
        return self.render(self.get_form(
            data=self.storage.current_step_data,
            files=self.storage.current_step_files,
        ), **kwargs)
    # invalid step name, reset to first and redirect.
    else:
        self.storage.current_step = self.steps.first
        return redirect(self.get_step_url(self.steps.first))

def get(self, request, *args, **kwargs):
    """
    This method handles GET requests.
    If a GET request reaches this point, the wizard assumes that the user
    just starts at the first step or wants to restart the process.
    The data of the wizard will be resetted before rendering the first step.
    """
    self.storage.reset()
    # reset the current step to the first step.
    self.storage.current_step = self.steps.first
    return self.render(self.get_form())

def get(self, request, *args, **kwargs):
    context = self.get_context_data(**kwargs)
    return self.render_to_response(context)

def get_context_data(self, form, **kwargs):
    """
    NamedUrlWizardView provides the url_name of this wizard in the context
    dict `wizard`.
    """
    context = super(NamedUrlWizardView, self).get_context_data(form=form, **kwargs)
    context['wizard']['url_name'] = self.url_name
    return context

def get_context_data(self, form, **kwargs):
    """
    Returns the template context for a step. You can overwrite this method
    to add more data for all or some steps. This method returns a
    dictionary containing the rendered form step. Available template
    context variables are:
     * all extra data stored in the storage backend
     * `form` - form instance of the current step
     * `wizard` - the wizard instance itself
    Example:
    .. code-block:: python
        class MyWizard(WizardView):
            def get_context_data(self, form, **kwargs):
                context = super(MyWizard, self).get_context_data(form=form, **kwargs)
                if self.steps.current == 'my_step_name':
                    context.update({'another_var': True})
                return context
    """
    context = super(WizardView, self).get_context_data(form=form, **kwargs)
    context.update(self.storage.extra_data)
    context['wizard'] = {
        'form': form,
        'steps': self.steps,
        'management_form': ManagementForm(prefix=self.prefix, initial={
            'current_step': self.steps.current,
        }),
    }
    return context

def get_context_data(self, **kwargs):
    if 'view' not in kwargs:
        kwargs['view'] = self
    return kwargs

@classmethod
def get_initkwargs(cls, *args, **kwargs):
    """
    We require a url_name to reverse URLs later. Additionally users can
    pass a done_step_name to change the URL name of the "done" view.
    """
    assert 'url_name' in kwargs, 'URL name is needed to resolve correct wizard URLs'
    extra_kwargs = {
        'done_step_name': kwargs.pop('done_step_name', 'done'),
        'url_name': kwargs.pop('url_name'),
    }
    initkwargs = super(NamedUrlWizardView, cls).get_initkwargs(*args, **kwargs)
    initkwargs.update(extra_kwargs)
    assert initkwargs['done_step_name'] not in initkwargs['form_list'], \
        'step name "%s" is reserved for "done" view' % initkwargs['done_step_name']
    return initkwargs

@classmethod
def get_initkwargs(cls, form_list, initial_dict=None,
        instance_dict=None, condition_dict=None, *args, **kwargs):
    """
    Creates a dict with all needed parameters for the form wizard instances.
    * `form_list` - is a list of forms. The list entries can be single form
      classes or tuples of (`step_name`, `form_class`). If you pass a list
      of forms, the wizardview will convert the class list to
      (`zero_based_counter`, `form_class`). This is needed to access the
      form for a specific step.
    * `initial_dict` - contains a dictionary of initial data dictionaries.
      The key should be equal to the `step_name` in the `form_list` (or
      the str of the zero based counter - if no step_names added in the
      `form_list`)
    * `instance_dict` - contains a dictionary whose values are model
      instances if the step is based on a ``ModelForm`` and querysets if
      the step is based on a ``ModelFormSet``. The key should be equal to
      the `step_name` in the `form_list`. Same rules as for `initial_dict`
      apply.
    * `condition_dict` - contains a dictionary of boolean values or
      callables. If the value of for a specific `step_name` is callable it
      will be called with the wizardview instance as the only argument.
      If the return value is true, the step's form will be used.
    """
    kwargs.update({
        'initial_dict': initial_dict or {},
        'instance_dict': instance_dict or {},
        'condition_dict': condition_dict or {},
    })
    init_form_list = SortedDict()
    assert len(form_list) > 0, 'at least one form is needed'
    # walk through the passed form list
    for i, form in enumerate(form_list):
        if isinstance(form, (list, tuple)):
            # if the element is a tuple, add the tuple to the new created
            # sorted dictionary.
            init_form_list[six.text_type(form[0])] = form[1]
        else:
            # if not, add the form with a zero based counter as unicode
            init_form_list[six.text_type(i)] = form
    # walk through the new created list of forms
    for form in six.itervalues(init_form_list):
        if issubclass(form, formsets.BaseFormSet):
            # if the element is based on BaseFormSet (FormSet/ModelFormSet)
            # we need to override the form variable.
            form = form.form
        # check if any form contains a FileField, if yes, we need a
        # file_storage added to the wizardview (by subclassing).
        for field in six.itervalues(form.base_fields):
            if (isinstance(field, forms.FileField) and
                    not hasattr(cls, 'file_storage')):
                raise NoFileStorageConfigured(
                        "You need to define 'file_storage' in your "
                        "wizard view in order to handle file uploads.")
    # build the kwargs for the wizardview instances
    kwargs['form_list'] = init_form_list
    return kwargs

def post(self, *args, **kwargs):
    """
    Do a redirect if user presses the prev. step button. The rest of this
    is super'd from WizardView.
    """
    wizard_goto_step = self.request.POST.get('wizard_goto_step', None)
    if wizard_goto_step and wizard_goto_step in self.get_form_list():
        self.storage.current_step = wizard_goto_step
        return redirect(self.get_step_url(wizard_goto_step))
    return super(NamedUrlWizardView, self).post(*args, **kwargs)

def post(self, *args, **kwargs):
    """
    This method handles POST requests.
    The wizard will render either the current step (if form validation
    wasn't successful), the next step (if the current step was stored
    successful) or the done view (if no more steps are available)
    """
    # Look for a wizard_goto_step element in the posted data which
    # contains a valid step name. If one was found, render the requested
    # form. (This makes stepping back a lot easier).
    wizard_goto_step = self.request.POST.get('wizard_goto_step', None)
    if wizard_goto_step and wizard_goto_step in self.get_form_list():
        self.storage.current_step = wizard_goto_step
        form = self.get_form(
            data=self.storage.get_step_data(self.steps.current),
            files=self.storage.get_step_files(self.steps.current))
        return self.render(form)
    # Check if form was refreshed
    management_form = ManagementForm(self.request.POST, prefix=self.prefix)
    if not management_form.is_valid():
        raise ValidationError(
            'ManagementForm data is missing or has been tampered.')
    form_current_step = management_form.cleaned_data['current_step']
    if (form_current_step != self.steps.current and
            self.storage.current_step is not None):
        # form refreshed, change current step
        self.storage.current_step = form_current_step
    # get the form for the current step
    form = self.get_form(data=self.request.POST, files=self.request.FILES)
    # and try to validate
    if form.is_valid():
        # if the form is valid, store the cleaned data and files.
        self.storage.set_step_data(self.steps.current, self.process_step(form))
        self.storage.set_step_files(self.steps.current, self.process_step_files(form))
        # check if the current step is the last step
        if self.steps.current == self.steps.last:
            # no more steps, render done view
            return self.render_done(form, **kwargs)
        else:
            # proceed to the next step
            return self.render_next_step(form)
    return self.render(form)

def render_done(self, form, **kwargs):
    """
    When rendering the done view, we have to redirect first (if the URL
    name doesn't fit).
    """
    if kwargs.get('step', None) != self.done_step_name:
        return redirect(self.get_step_url(self.done_step_name))
    return super(NamedUrlWizardView, self).render_done(form, **kwargs)

def render_done(self, form, **kwargs):
    """
    This method gets called when all forms passed. The method should also
    re-validate all steps to prevent manipulation. If any form don't
    validate, `render_revalidation_failure` should get called.
    If everything is fine call `done`.
    """
    final_form_list = []
    # walk through the form list and try to validate the data again.
    for form_key in self.get_form_list():
        form_obj = self.get_form(step=form_key,
            data=self.storage.get_step_data(form_key),
            files=self.storage.get_step_files(form_key))
        if not form_obj.is_valid():
            return self.render_revalidation_failure(form_key, form_obj, **kwargs)
        final_form_list.append(form_obj)
    # render the done view and reset the wizard before returning the
    # response. This is needed to prevent from rendering done with the
    # same data twice.
    done_response = self.done(final_form_list, **kwargs)
    self.storage.reset()
    return done_response

def render_next_step(self, form, **kwargs):
    """
    When using the NamedUrlWizardView, we have to redirect to update the
    browser's URL to match the shown step.
    """
    next_step = self.get_next_step()
    self.storage.current_step = next_step
    return redirect(self.get_step_url(next_step))

def render_next_step(self, form, **kwargs):
    """
    This method gets called when the next step/form should be rendered.
    `form` contains the last/current form.
    """
    # get the form instance based on the data from the storage backend
    # (if available).
    next_step = self.steps.next
    new_form = self.get_form(next_step,
        data=self.storage.get_step_data(next_step),
        files=self.storage.get_step_files(next_step))
    # change the stored current step
    self.storage.current_step = next_step
    return self.render(new_form, **kwargs)

def render_revalidation_failure(self, failed_step, form, **kwargs):
    """
    When a step fails, we have to redirect the user to the first failing
    step.
    """
    self.storage.current_step = failed_step
    return redirect(self.get_step_url(failed_step))

def render_revalidation_failure(self, step, form, **kwargs):
    """
    Gets called when a form doesn't validate when rendering the done
    view. By default, it changes the current step to failing forms step
    and renders the form.
    """
    self.storage.current_step = step
    return self.render(form, **kwargs)