How to use the nltools.tokenizer.tokenize function in nltools

tokenize(u'die leistung wurde zurückverlangt')), 0)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'die leistung wurde'), 
                             tokenize(u'die leistung wurde zurückverlangt')), 1)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG'), 
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE'), 
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT')), 3)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE ZURÜCKVERLANGT'), 
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'LEISTUNG WURDE ZURÜCKVERLANGT')), 1)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'ZURÜCKVERLANGT')), 3)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'')), 4)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'LEISTUNG FOO ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'SIE IST FÜR DIE LEISTUNG DANKBAR'), 
                             tokenize(u'SIE STRITTIG LEISTUNG DANKBAR')), 3)

tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'LEISTUNG WURDE ZURÜCKVERLANGT')), 1)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'ZURÜCKVERLANGT')), 3)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'')), 4)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'LEISTUNG FOO ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'SIE IST FÜR DIE LEISTUNG DANKBAR'), 
                             tokenize(u'SIE STRITTIG LEISTUNG DANKBAR')), 3)

tokenize(u'die leistung wurde zurückverlangt'), 
                             tokenize(u'die leistung wurde zurückverlangt')), 0)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'die leistung wurde'), 
                             tokenize(u'die leistung wurde zurückverlangt')), 1)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG'), 
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE'), 
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT')), 3)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE ZURÜCKVERLANGT'), 
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'LEISTUNG WURDE ZURÜCKVERLANGT')), 1)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'WURDE ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'ZURÜCKVERLANGT')), 3)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'')), 4)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'DIE LEISTUNG WURDE ZURÜCKVERLANGT'), 
                             tokenize(u'LEISTUNG FOO ZURÜCKVERLANGT')), 2)
        self.assertEqual (misc.edit_distance(
                             tokenize(u'SIE IST FÜR DIE LEISTUNG DANKBAR'), 
                             tokenize(u'SIE STRITTIG LEISTUNG DANKBAR')), 3)

code = self._parse_begin(lx)
            code_s = u'\n'.join(code)

            env_locals = { 'rdf'   : rdf,
                           'lang'  : lang,
                           'kernal': self.kernal,
                           'kb'    : self.kernal.kb }

            exec code_s in env_locals

            resps = []
            for r in env_locals['data']:
                r2 = {}
                for vn in r:    
                    r2[vn]= tokenize(r[vn], lang=lang, keep_punctuation=True)
                resps.append(r2)

        elif lx.cur_sym == SYM_LINE:

            # vs   = self.cur_line.split(':')[3:]

            # self.next_line()

            resps = []

            while lx.cur_sym == SYM_LINE:

                line_parts = lx.cur_s.split('@')

                for el, empos in self._expand_macros (lang, line_parts[0], lx):

for s in macro_s.split('|'):
                    implicit_macros[macro_name].append({'W': s.strip()})

                nlp_input2 += '@' + macro_name + ':W '

                i = j+2
            else:

                nlp_input2 += nlp_input[i]
                i+=1

        # print "implicit macros: %s" % repr(implicit_macros)

        # extract all macros used

        nlp_tokens = tokenize (nlp_input2, lang=lang, keep_macros=True)

        #logging.debug('nlp_tokens: %s' % repr(nlp_tokens))

        macro_names = set()

        for i, token in enumerate(nlp_tokens):
            if token[0] != '@':
                continue
            token = token.upper()
            nlp_tokens[i] = token
            parts = token[1:].split(':')
            if len(parts) != 2:
                raise PrologError('invalid macro call detected: %s (@macroname:variable expected)' % token, location)
                
            macro_names.add(parts[0])

def add_missing_words(transcripts, lex, sequitur_model_path):
    logging.info("looking for missing words...")
    missing = {}  # word -> count
    num = len(transcripts)
    cnt = 0
    for cfn in transcripts:
        ts = transcripts[cfn]

        cnt += 1

        if ts['quality'] > 0:
            continue

        for word in tokenize(ts['prompt']):
            if word in lex:
                continue

            if word in missing:
                missing[word] += 1
            else:
                missing[word] = 1
    cnt = 0
    for item in reversed(sorted(missing.items(), key=lambda x: x[1])):
        lex_base = item[0]

        ipas = sequitur_gen_ipa(sequitur_model_path, lex_base)

        logging.info(u"%5d/%5d Adding missing word : %s [ %s ]" % (
        cnt, len(missing), item[0], ipas))

s3 = tokenize (s3, lang=lang)
                            r3[vn] = s3
                        r1.extend(r3[vn])
                        mpos1['%s_%d_end' % (name, mpnn)]   = len(r1)

                        for vn3 in r3:
                            mpos1['%s_%d_%s' % (name, mpnn, vn3.lower())] = r3[vn3]

                        todo.append((parts, cnt+1, r1, mpos1, macro_rs1))
                        
                        # if name == 'home_locations':
                        #     import pdb; pdb.set_trace()

            else:

                sub_parts = tokenize(p1, lang=lang, keep_punctuation=False)

                r  = copy(r)
                r.extend(sub_parts)

                todo.append((parts, cnt+1, r, mpos, macro_rs))

        return done

mpnn = 0
                        while True:
                            mpn = '%s_%d_start' % (name, mpnn)
                            if not mpn in mpos1:
                                break
                            mpnn += 1

                        mpos1['%s_%d_start' % (name, mpnn)] = len(r1)
                        r1.extend(r3[vn])
                        mpos1['%s_%d_end' % (name, mpnn)]   = len(r1)
                        todo.append((parts, cnt+1, r1, mpos1))
                        
            else:

                sub_parts = tokenize(p1, lang=lang, keep_punctuation=False)

                r  = copy(r)
                r.extend(sub_parts)

                todo.append((parts, cnt+1, r, mpos))

        return done

continue

            # tokenizer debugging
            # if u"'" in question:
            #     logging.info(question)
            #     logging.info(utt)

            lq = len(tq)
            la = len(ta)

            if lq>options.limit or la>options.limit:
                skipped += 1
                continue

            if options.tokenize:
                tq2 = tokenizer.tokenize(question, keep_punctuation=True, lang=lang)
                ta2 = tokenizer.tokenize(answer,   keep_punctuation=True, lang=lang)
                question = u' '.join(tq2)
                answer   = u' '.join(ta2)

            corpus[utt] = (question, answer)

            cnt += 1
            if cnt % 1000 == 0:
                print "%6d rounds, %6d skipped" % (cnt, skipped)


with codecs.open(outputfn, 'w', 'utf8') as outputf:

    outputf.write ('%prolog\n\n')
    outputf.write ('train_priority(%d).\n\n' % options.prio)
    outputf.write ("train_prefix('{self_address:L} ').\n\n")

if tmpl.find(AIML_SET, ns) is not None:
                    keep_xml = True
                    skip_pattern = True
                if tmpl.find(AIML_GET, ns) is not None:
                    keep_xml = True
                    skip_pattern = True

                # print '   ', t

                if not skip_pattern:
                    pt = pt.lower()

                    # check for empty utterances, ignore those
                    if len(tokenize(t, lang=options.lang))==0:
                        continue
                    if len(tokenize(pt, lang=options.lang))==0:
                        continue

                    res[pt] = t

                    cnt += 1
                    if cnt % 1000 == 0:
                        logging.info('   %6d samples extracted.' % cnt)

        logging.info('   %6d samples extracted from this AIML. Unique: %6d' % (cnt, len(res)))

    except:
        logging.error(traceback.format_exc())

with codecs.open(outputfn, 'w', 'utf8') as outputf:

    for pt in sorted(res):