@classmethod
def wrap(cls, models, build=True, handler=None, **kwargs):
    """
        "Wraps" the provided sequence (or single set) of model based data into a
        sequence of models (or a single model) so that proper business logic may
        be used for operations on top of that data.

        In case the extra handler argument is passed it's going to be called for
        each model that is going to be "wrapped" allowing an extra "layer" for
        the transformation of the model.

        The additional named arguments parameters allows extensibility to set
        extra value in the creation of the wrapped object.

        This operation is specially useful for API based environments where client
        side business logic is meant to be added to the static data.

        :type models: List
        :param models: Sequence (or single) set of models that are going to be wrapped
        around instances of the current class.
        :type build: bool
        :param build: If the "custom" build operation should be performed after
        the wrap operation is performed so that new custom attributes may be
        injected into the resulting instance.
        :type handler: Function
        :param handler: Handler function that is going to be called for each of the
        models after the build process has been performed, allows an extra transform
        operation to be performed at runtime.
        :rtype: List
        :return: The sequence of models (or single model) representing the provided
        set of dictionary models that were sent as arguments.
        """
    is_sequence = isinstance(models, (list, tuple))
    if not is_sequence:
        models = [models]
    wrapping = []
    for model in models:
        if not isinstance(model, dict):
            continue
        _model = cls(model=model, **kwargs)
        handler and handler(_model.model)
        build and cls.build(_model.model, map=False)
        wrapping.append(_model)
    if is_sequence:
        return wrapping
    else:
        return wrapping[0] if wrapping else None
