class WizardView

def __init__(self, **kwargs):
    """
    Constructor. Called in the URLconf; can contain helpful extra
    keyword arguments, and other things.
    """
    # Go through keyword arguments, and either save their values to our
    # instance, or raise an error.
    for key, value in six.iteritems(kwargs):
        setattr(self, key, value)

def __repr__(self):
    return '<%s: forms: %s>' % (self.__class__.__name__, self.form_list)

def _allowed_methods(self):
    return [m.upper() for m in self.http_method_names if hasattr(self, m)]

def done(self, form_list, **kwargs):
    """
    This method must be overridden by a subclass to process to form data
    after processing all steps.
    """
    raise NotImplementedError("Your %s class has not defined a done() "
        "method, which is required." % self.__class__.__name__)

def get_all_cleaned_data(self):
    """
    Returns a merged dictionary of all step cleaned_data dictionaries.
    If a step contains a `FormSet`, the key will be prefixed with
    'formset-' and contain a list of the formset cleaned_data dictionaries.
    """
    cleaned_data = {}
    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 form_obj.is_valid():
            if isinstance(form_obj.cleaned_data, (tuple, list)):
                cleaned_data.update({
                    'formset-%s' % form_key: form_obj.cleaned_data
                })
            else:
                cleaned_data.update(form_obj.cleaned_data)
    return cleaned_data

def get_cleaned_data_for_step(self, step):
    """
    Returns the cleaned data for a given `step`. Before returning the
    cleaned data, the stored values are revalidated through the form.
    If the data doesn't validate, None will be returned.
    """
    if step in self.form_list:
        form_obj = self.get_form(step=step,
            data=self.storage.get_step_data(step),
            files=self.storage.get_step_files(step))
        if form_obj.is_valid():
            return form_obj.cleaned_data
    return None

def get_form(self, step=None, data=None, files=None):
    """
    Constructs the form for a given `step`. If no `step` is defined, the
    current step will be determined automatically.
    The form will be initialized using the `data` argument to prefill the
    new form. If needed, instance or queryset (for `ModelForm` or
    `ModelFormSet`) will be added too.
    """
    if step is None:
        step = self.steps.current
    # prepare the kwargs for the form instance.
    kwargs = self.get_form_kwargs(step)
    kwargs.update({
        'data': data,
        'files': files,
        'prefix': self.get_form_prefix(step, self.form_list[step]),
        'initial': self.get_form_initial(step),
    })
    if issubclass(self.form_list[step], forms.ModelForm):
        # If the form is based on ModelForm, add instance if available
        # and not previously set.
        kwargs.setdefault('instance', self.get_form_instance(step))
    elif issubclass(self.form_list[step], forms.models.BaseModelFormSet):
        # If the form is based on ModelFormSet, add queryset if available
        # and not previous set.
        kwargs.setdefault('queryset', self.get_form_instance(step))
    return self.form_list[step](**kwargs)

def get_form_initial(self, step):
    """
    Returns a dictionary which will be passed to the form for `step`
    as `initial`. If no initial data was provied while initializing the
    form wizard, a empty dictionary will be returned.
    """
    return self.initial_dict.get(step, {})

def get_form_instance(self, step):
    """
    Returns a object which will be passed to the form for `step`
    as `instance`. If no instance object was provied while initializing
    the form wizard, None will be returned.
    """
    return self.instance_dict.get(step, None)

def get_form_kwargs(self, step=None):
    """
    Returns the keyword arguments for instantiating the form
    (or formset) on the given step.
    """
    return {}

def get_form_list(self):
    """
    This method returns a form_list based on the initial form list but
    checks if there is a condition method/value in the condition_list.
    If an entry exists in the condition list, it will call/read the value
    and respect the result. (True means add the form, False means ignore
    the form)
    The form_list is always generated on the fly because condition methods
    could use data from other (maybe previous forms).
    """
    form_list = SortedDict()
    for form_key, form_class in six.iteritems(self.form_list):
        # try to fetch the value from condition list, by default, the form
        # gets passed to the new list.
        condition = self.condition_dict.get(form_key, True)
        if callable(condition):
            # call the value if needed, passes the current instance.
            condition = condition(self)
        if condition:
            form_list[form_key] = form_class
    return form_list

def get_form_prefix(self, step=None, form=None):
    """
    Returns the prefix which will be used when calling the actual form for
    the given step. `step` contains the step-name, `form` the form which
    will be called with the returned prefix.
    If no step is given, the form_prefix will determine the current step
    automatically.
    """
    if step is None:
        step = self.steps.current
    return str(step)

def get_form_step_data(self, form):
    """
    Is used to return the raw form data. You may use this method to
    manipulate the data.
    """
    return form.data

def get_form_step_files(self, form):
    """
    Is used to return the raw form files. You may use this method to
    manipulate the data.
    """
    return form.files

@classmethod
def get_initkwargs(cls, form_list=None, 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 kwargs.pop('initial_dict',
            getattr(cls, 'initial_dict', None)) or {},
        'instance_dict': instance_dict or kwargs.pop('instance_dict',
            getattr(cls, 'instance_dict', None)) or {},
        'condition_dict': condition_dict or kwargs.pop('condition_dict',
            getattr(cls, 'condition_dict', None)) or {}
    })
    form_list = form_list or kwargs.pop('form_list',
        getattr(cls, 'form_list', None)) or []
    computed_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.
            computed_form_list[six.text_type(form[0])] = form[1]
        else:
            # if not, add the form with a zero based counter as unicode
            computed_form_list[six.text_type(i)] = form
    # walk through the new created list of forms
    for form in six.itervalues(computed_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'] = computed_form_list
    return kwargs

def get_next_step(self, step=None):
    """
    Returns the next step after the given `step`. If no more steps are
    available, None will be returned. If the `step` argument is None, the
    current step will be determined automatically.
    """
    if step is None:
        step = self.steps.current
    form_list = self.get_form_list()
    key = form_list.keyOrder.index(step) + 1
    if len(form_list.keyOrder) > key:
        return form_list.keyOrder[key]
    return None

def get_prefix(self, *args, **kwargs):
    # TODO: Add some kind of unique id to prefix
    return normalize_name(self.__class__.__name__)

def get_prev_step(self, step=None):
    """
    Returns the previous step before the given `step`. If there are no
    steps available, None will be returned. If the `step` argument is
    None, the current step will be determined automatically.
    """
    if step is None:
        step = self.steps.current
    form_list = self.get_form_list()
    key = form_list.keyOrder.index(step) - 1
    if key >= 0:
        return form_list.keyOrder[key]
    return None

def get_step_index(self, step=None):
    """
    Returns the index for the given `step` name. If no step is given,
    the current step will be used to get the index.
    """
    if step is None:
        step = self.steps.current
    return self.get_form_list().keyOrder.index(step)

def get_template_names(self):
    """
    Returns a list of template names to be used for the request. Must return
    a list. May not be called if render_to_response is overridden.
    """
    if self.template_name is None:
        raise ImproperlyConfigured(
            "TemplateResponseMixin requires either a definition of "
            "'template_name' or an implementation of 'get_template_names()'")
    else:
        return [self.template_name]

def http_method_not_allowed(self, request, *args, **kwargs):
    logger.warning('Method Not Allowed (%s): %s', request.method, request.path,
        extra={
            'status_code': 405,
            'request': self.request
        }
    )
    return http.HttpResponseNotAllowed(self._allowed_methods())

def options(self, request, *args, **kwargs):
    """
    Handles responding to requests for the OPTIONS HTTP verb.
    """
    response = http.HttpResponse()
    response['Allow'] = ', '.join(self._allowed_methods())
    response['Content-Length'] = '0'
    return response

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():
        return self.render_goto_step(wizard_goto_step)
    # 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.'),
            code='missing_management_form',
        )
    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 process_step(self, form):
    """
    This method is used to postprocess the form data. By default, it
    returns the raw `form.data` dictionary.
    """
    return self.get_form_step_data(form)

def process_step_files(self, form):
    """
    This method is used to postprocess the form files. By default, it
    returns the raw `form.files` dictionary.
    """
    return self.get_form_step_files(form)

def render(self, form=None, **kwargs):
    """
    Returns a ``HttpResponse`` containing all needed context data.
    """
    form = form or self.get_form()
    context = self.get_context_data(form=form, **kwargs)
    return self.render_to_response(context)

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_goto_step(self, goto_step, **kwargs):
    """
    This method gets called when the current step has to be changed.
    `goto_step` contains the requested step to go to.
    """
    self.storage.current_step = 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)

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, 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)

def render_to_response(self, context, **response_kwargs):
    """
    Returns a response, using the `response_class` for this
    view, with a template rendered with the given context.
    If any keyword arguments are provided, they will be
    passed to the constructor of the response class.
    """
    response_kwargs.setdefault('content_type', self.content_type)
    return self.response_class(
        request = self.request,
        template = self.get_template_names(),
        context = context,
        **response_kwargs
    )