Maybe just add a comment here to say that this does the same thing as the fist iteration of the loop below (which is then skipped) as that's not entirely clear from reading it.

as a quick glance I would say that most of the time will be spend on the slicing original_tokens[i: i + n], it might be possible to swap the two loops to get something like (roughly)

for i in ...:
    _current = ''
    for _tok in original_tokens[i:i + n]:
            _current = _current+' '+_tok
            tokens_append(
                _current
            )

Thus only iterating over the slice, which should likely be faster as well.
Would need to be profiled though.

Actually there seem to be an even simpler way, using the following

import itertools
def iter_window(seq, n):
    l = list(seq[:n])
    append = l.append
    for item in itertools.islice(seq, n-1, len(seq)):
        yield tuple(l)
        l.pop(0)
        l.append(item)
    yield tuple(l)

and then replacing the inner loop by

for n in range(a,b):
            for _tks in iter_window(original_tokens,n, c-1):
                tokens_append(
                    space_join(
                        _tks
                    )
                )

I get a ~2+ speedup (increasing with lenght of ngrams) and the sliding window implementation can likely be made much more efficient using a dequeue maybe.

Same comment as above

Could we please get a benchmark on writing this as a list comprehension:

n_grams.extend([text_document[i: i + n]]
               for n in xrange(min_n, min(max_n + 1, text_len + 1))
               for i in xrange(text_len - n + 1))

?

Also benchmark returning a generator i.e. use itertools.chain over generator expressions to see if the counting can benefit from not materialising the list.

Sure. I tried several variations of list comprehension and generators (and a couple other shortcuts). Looks like creating all the ngrams as a single list comprehension is faster than a generator.