def prefixs_for_term (self,term):
    """
    Get prefixs for TERM.
    """
    # Normalization
    term=term.lower()

    # Prefixs for term
    prefixs=[]
    for i in xrange(1, len(term) + 1):
      word = term[:i]
      prefixs.append(word)
      prefixs.append(''.join([i[0] for i in pinyin(word, style=pypinyin.FIRST_LETTER)]).lower())
      prefixs.append(''.join([i[0] for i in pinyin(word, style=pypinyin.NORMAL)]).lower())
      prefixs.append(word)

    tokens = self.normalize(term)
    for token in tokens:
      for i in xrange (1,len(token)+1):
        word = token[:i]
        prefixs.append(word)
        prefixs.append(''.join([i[0] for i in pinyin(word, style=pypinyin.FIRST_LETTER)]).lower())
        prefixs.append(''.join([i[0] for i in pinyin(word, style=pypinyin.NORMAL)]).lower())
        prefixs.append(word)

    return list(set(prefixs))

 def get_pinyin(self):
     su_temp = pinyin(self.names[0], style=pypinyin.NORMAL,heteronym=True)
     fn_temp = pinyin(self.names[1], style=pypinyin.NORMAL, heteronym=True)
     su_py = self.combination(self, su_temp, '')
     fn_py = self.combination(self, fn_temp, '')
     pys = self.combination(self, [su_py, fn_py], ' ')
     return pys

def test_zh_and_en():
    """中英文混合的情况"""
    # 中英文
    hans = '中心'
    try:
        assert pinyin(hans + 'abc') == [['zh\u014dng'], ['x\u012bn'], ['abc']]
    except AssertionError:
        assert pinyin(hans + 'abc') == [['zh\u014dng'], ['x\u012bn'],
                                        ['a'], ['b'], ['c']]

def test_errors_callable():
    def foobar(chars):
        return 'a' * len(chars)

    class Foobar(object):
        def __call__(self, chars):
            return 'a' * len(chars)

    n = 5
    assert pinyin('あ' * n, errors=foobar) == [['a' * n]]
    assert pinyin('あ' * n, errors=Foobar()) == [['a' * n]]

def test_others():
    # 空字符串
    assert pinyin('') == []
    # 单个汉字
    assert pinyin('營') == [['y\xedng']]
    # 中国 人
    assert pinyin('中国人') == [['zh\u014dng'], ['gu\xf3'], ['r\xe9n']]
    # 日文
    assert pinyin('の') == [['\u306e']]
    # 没有读音的汉字，还不存在的汉字
    assert pinyin('\u9fff') == [['\u9fff']]

def get_homophones_by_char(input_char):
    """
    根据汉字取同音字
    :param input_char:
    :return:
    """
    result = []
    # CJK统一汉字区的范围是0x4E00-0x9FA5,也就是我们经常提到的20902个汉字
    for i in range(0x4e00, 0x9fa6):
        if pinyin([chr(i)], style=pypinyin.NORMAL)[0][0] == pinyin(input_char, style=pypinyin.NORMAL)[0][0]:
            result.append(chr(i))
    return result

def test_custom_style_with_decorator():
    style_value = 'test_custom_style_with_decorator'

    @register(style_value)
    def func(pinyin, **kwargs):
        return pinyin + str(len(pinyin))

    hans = '北京'
    origin_pinyin_s = pinyin(hans)
    expected_pinyin_s = deepcopy(origin_pinyin_s)
    for pinyin_s in expected_pinyin_s:
        for index, py in enumerate(pinyin_s):
            pinyin_s[index] = func(py)

    assert pinyin(hans, style=style_value) == expected_pinyin_s

def lang_zh(text):
    res = []
    for line in text.split('\n'):
        cut = jieba.cut(line)
        ln = [[i, "'".join(j[0] for j in pypinyin.pinyin(i, style=0))] for i in cut]
        res.append(ln)
    return res

 def get_following_users(self, user):
     doc = yield self._db.followers.find_one({"user": user}, {"_id":0, "following":1})
     if doc and "following" in doc:
         ret = yield [self.find_user(_, True) for _ in doc["following"] if _]
     else:
         ret = []
     raise gen.Return(sorted(ret, key=lambda x: pinyin(to_unicode(("real_name" in x and x["real_name"]) or ""), style=TONE2)))

    def _du(self, _request, _rdata):
        if "user_uuid" not in _request:
            self.setErrorCode(API_ERR.NO_PARA)
            logging.error("Error for no para: %s.", (str(_request)))
            return

        _o = redis_hash_to_dict(self.application.redis, DeviceUser, _request["user_uuid"])

        logging.info(_o)
        
        if _o == None:
            self.setErrorCode(API_ERR.NO_OBJECT)
            logging.error("Error for no user uuid: %s." % (_request["user_uuid"]))
            return

        # not return the password default
        return_password = False
        if "return_password" in _request:
            return_password = _request["return_password"]
        if not return_password:
            del _o["user_password"]
        
        _fn = _o.get("user_fullname")
        if _fn != None and not isinstance(_fn, unicode):
            _fn = _fn.decode("utf-8")

        _rdata.update(_o)
        _rdata["pinyinname0"] = "".join(lazy_pinyin(_fn))
        _rdata["pinyinname1"] = "".join(list(itertools.chain.from_iterable(pinyin(_fn, style=pypinyin.INITIALS))))
        
        return

def _get_pinyin_all(existing_combinations, characters):
    """
    Get all combinations of pinyin of some chinese characters as list, in a 
    recurrence way, since format of result from pinyin is [['a'], ['b']]
    So a combination of two level loop is needed to get all the pinyin. 
    :param existing_combinations:  Existing combinations, for already calculated characters. 
    :param characters: Characters to get combination of pinyin 
    :return:  A flat list of all combinations of pinyin for 多音字
    """
    first_character, other_characters = characters[0:1], characters[1:]
    if len(first_character) > 0:
        py = pinyin(first_character, style=pypinyin.FIRST_LETTER, heteronym=True)
        new_existing = []
        for p in py:
            for a in p:
                if len(existing_combinations) > 0:
                    for e in existing_combinations:
                        ne = e[:]
                        ne.append(a)
                        new_existing.append(ne)
                else:
                    ne = existing_combinations[:]
                    ne.append(a)
                    new_existing.append(ne)
        return _get_pinyin_all(new_existing, other_characters)
    return existing_combinations

def test_errors():
    hans = (
        ('啊', {'style': TONE2}, [['a']]),
        ('啊a', {'style': TONE2}, [['a'], ['a']]),
        # 非中文字符，没有拼音
        ('⺁', {'style': TONE2}, [['\u2e81']]),
        ('⺁', {'style': TONE2, 'errors': 'ignore'}, []),
        ('⺁', {'style': TONE2, 'errors': 'replace'}, [['2e81']]),
        ('⺁⺁', {'style': TONE2, 'errors': 'replace'}, [['2e812e81']]),
        ('⺁⺁', {'style': TONE2, 'errors': lambda x: ['a' for _ in x]},
         [['a'], ['a']]),
        ('⺁⺁', {'style': TONE2, 'errors': lambda x: [['a', 'b'], ['b', 'c']]},
         [['a'], ['b']]),
        ('⺁⺁', {'style': TONE2, 'heteronym': True,
                'errors': lambda x: [['a', 'b'], ['b', 'c']]},
         [['a', 'b'], ['b', 'c']]),
        # 中文字符，没有拼音
        ('鿅', {'style': TONE2}, [['\u9fc5']]),
        ('鿅', {'style': TONE2, 'errors': 'ignore'}, []),
        ('鿅', {'style': TONE2, 'errors': '233'}, []),
        ('鿅', {'style': TONE2, 'errors': 'replace'}, [['9fc5']]),
        ('鿅', {'style': TONE2, 'errors': lambda x: ['a']}, [['a']]),
        ('鿅', {'style': TONE2, 'errors': lambda x: None}, []),
        ('鿅鿅', {'style': TONE2, 'errors': lambda x: ['a' for _ in x]},
         [['a'], ['a']]),
        ('鿅鿅', {'style': TONE2, 'errors': lambda x: [['a', 'b']]},
         [['a'], ['a']]),
        ('鿅鿅', {'style': TONE2, 'heteronym': True,
                'errors': lambda x: [['a', 'b']]},
         [['a', 'b'], ['a', 'b']]),
    )
    for han in hans:
        assert pinyin(han[0], **han[1]) == han[2]

def add_term(term, weight):
    words, types = term2words(term)
    if len(words) == 0: #avoid '......'
        return
    #max prefix match
    level, node_id = max_prefix_match(words, types)
    
    # 如果全部存在这个字符序列，则更新 node_id
    if level == len(words):#exist already
        add_weight(node_id, weight)#may lead to parent weight bigger than weight sum of all children
    else:
        for word in words[level:]:
            #insert normal node
            parent = node_id
            node_id = new_node(word, parent)
            if len(word)==1 and ord(word)>=19904 and ord(word)<=40895:
                #insert pinyin node
                pys = pypinyin.pinyin(word, style=pypinyin.NORMAL, heteronym=True)
                for py in pys[0]:
                    #complete pinyin
                    push_pinyin_node(parent, node_id, py)
                    push_pinyin_node(parent, node_id, py[0])
                    if py[0]=='c' or py[0]=='s' or py[0]=='z':
                        if py[1] == 'h':
                            push_pinyin_node(parent, node_id, py[:2])
                
        add_weight(node_id, weight)

    def _du(self):

        _request = json.loads(self.request.body)

        _user_uuid = _request.get("user_uuid")
        if not _user_uuid:
            self.setErrorCode(API_ERR.NO_PARA)
            return

        _o = redis_hash_to_dict(self.application.redis, DeviceUser, _user_uuid)
        if not _o:
            self.setErrorCode(API_ERR.NO_OBJECT)
            return

        # not return the password default
        return_password = False
        if "return_password" in _request:
            return_password = _request["return_password"]
        if not return_password:
            del _o["user_password"]
        
        _fn = _o.get("user_fullname")
        if _fn != None and not isinstance(_fn, unicode):
            _fn = _fn.decode("utf-8")

        _rdata = self.getReturnData()
        _rdata.update(_o)
        _rdata["pinyinname0"] = "".join(lazy_pinyin(_fn))
        _rdata["pinyinname1"] = "".join(list(itertools.chain.from_iterable(pinyin(_fn, style=pypinyin.INITIALS))))

        _app_uuid = _get_config().get("team").get("app_uuid")
        _o = redis_hash_to_dict(self.application.redis, AppInfo, _app_uuid)
        _rdata.update({"team": _o});
        return

def addPinyin(sometext):
    mylist=pinyin(sometext, heteronym=True)
    str=u''
    for pp in mylist:
        str+=pp[0]+u' '
    print str.rstrip()
    return str.rstrip()

def addPinyin(sometext):
    mylist=pinyin(sometext,heteronym=True)
    str=u''
    for pp in mylist:
        str+=pp[0]+u' '
#去除最后空格
    
    return strB2Q(str.rstrip())

def get_pinyin(text):
    pinyin_list = pinyin(text, style=pypinyin.TONE3)
    strs = ''
    for i in range(0,len(pinyin_list)):
        if strs != None:
            strs = strs + ' ' + pinyin_list[i][0]
        else:
            strs = pinyin_list[i][0]
    return strs

 def get_university_by_province(self, province, need_pinyin=True):
     if province in self._university_of_province:
         if need_pinyin:
             return [{"university": u, "pinyin": self.to_pinyin(u)}
                     for u in self._university_of_province[province]]
         else:
             return sorted(self._university_of_province[province], key=lambda x: pinyin(to_unicode(x), style=TONE2))
     else:
         return []

def test_pinyin():
    hans = u'中心'
    assert pinyin(hans) == [[u'zh\u014dng'], [u'x\u012bn']]
    assert pinyin(hans + 'abc') == [[u'zh\u014dng'], [u'x\u012bn'], ['abc']]
    assert pinyin(hans, pypinyin.STYLE_NORMAL) == [[u'zhong'], [u'xin']]
    assert pinyin(hans, pypinyin.STYLE_TONE) == [[u'zh\u014dng'], [u'x\u012bn']]
    assert pinyin(hans, pypinyin.STYLE_TONE2) == [[u'zho1ng'], [u'xi1n']]
    assert pinyin(hans, pypinyin.STYLE_INITIALS) == [['zh'], ['x']]
    assert pinyin(hans, pypinyin.STYLE_FIRST_LETTER) == [[u'z'], [u'x']]
    assert pinyin(hans, heteronym=True) == [[u'zh\u014dng', u'zh\xf2ng'],
                                            [u'x\u012bn']]

def name2pinyin(name):
    input = name.decode('utf-8')

    letter_list = pinyin(input, 4)
    #print letter_list
    output = "".join([ x[0] for x in letter_list])
    output = safestr(output)
    #print safestr(name), safestr(input), output

    return output