Exemplo n.º 1
0
class ChatBotService:
    def __init__(self):
        self.bot = ChatBot(
            'line-bot',
            storage_adapter='chatterbot.storage.SQLStorageAdapter',
            database='db.sqlite3')
        self.bot.set_trainer(ChatterBotCorpusTrainer)
        self.bot.train('chatterbot.corpus.chinese')
        self.openCC_s2t = OpenCC('s2t')
        self.openCC_s2t.set_conversion('s2tw')
        self.openCC_t2s = OpenCC('t2s')
        self.openCC_t2s.set_conversion('tw2s')

    def ask_question(self, message):
        question = self.openCC_t2s.convert(message)
        response = str(self.bot.get_response(question))
        response = self.openCC_s2t.convert(response)
        return response
def main(args):
    current_path = os.getcwd()
    logging.info(f'current python path {current_path}...')
    
    logging.info(f'Load Bert tokenizer...')
    pretrained_bert = "bert-base-chinese"
    tokenizer = BertTokenizer.from_pretrained(pretrained_bert, do_lower_case=True)

    cc = OpenCC('s2t')  # convert from Simplified Chinese to Traditional Chinese
    cc.set_conversion('s2tw') # can also set conversion by calling set_conversion
    
    logging.info(f'Load training data...')
    with open(f'{current_path}/model_1/pkl/NER/boston.pkl', 'rb')as f:
        train = pickle.load(f)

    with open(f'{current_path}/model_1/pkl/NER/asia_institute.pkl', 'rb')as f:
        train2 = pickle.load(f)

    with open(f'{current_path}/model_1/pkl/NER/people.pkl', 'rb')as f:
        train3 = pickle.load(f)

    all_train = train + train2 + train3

    bert_dataset = Bert_dataset(all_train)
    
    logging.info(f'Split dataset and save it as pkl to {args.save_path}...')
    torch.manual_seed(0)
    train_dataset, test_dataset = random_split(bert_dataset,
                                               [int(len(bert_dataset)*0.8), 
                                                len(bert_dataset)-int(len(bert_dataset)*0.8)])

    valid_dataset, test_dataset = random_split(test_dataset, 
                                               [int(len(test_dataset)*0.5), 
                                                len(test_dataset)-int(len(test_dataset)*0.5)])

    
    with open(f'{args.save_path}/train_dataset.pkl', 'wb') as f:
        pickle.dump(train_dataset, f)
    with open(f'{args.save_path}/valid_dataset.pkl', 'wb') as f:
        pickle.dump(valid_dataset, f)
    with open(f'{args.save_path}/test_dataset.pkl', 'wb') as f:
        pickle.dump(test_dataset, f)
        
    logging.info('Finish!')
Exemplo n.º 3
0
class OpenCCTest(unittest.TestCase):
    def setUp(self):
        self.openCC = OpenCC()

    def test_hk2s(self):
        self.openCC.set_conversion('hk2s')
        words = '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')

    def test_s2hk(self):
        self.openCC.set_conversion('s2hk')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香煙(英語:Cigarette),為煙草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2t(self):
        self.openCC.set_conversion('s2t')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2tw(self):
        self.openCC.set_conversion('s2tw')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),為菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2twp(self):
        self.openCC.set_conversion('s2twp')
        words = '香烟(英语:Cigarette),为烟草制品的一种。內存是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。')

    def test_t2hk(self):
        self.openCC.set_conversion('t2hk')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。')

    def test_t2s(self):
        self.openCC.set_conversion('t2s')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入装置。')

    def test_t2tw(self):
        self.openCC.set_conversion('t2tw')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),為菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_tw2s(self):
        self.openCC.set_conversion('tw2s')
        words = '香菸(英語:Cigarette),為菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入装置。')

    def test_tw2sp(self):
        self.openCC.set_conversion('tw2sp')
        words = '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。内存是一种很常见及常用的电脑输入设备。')
# -*- coding: UTF-8 -*-
__author__ = "Powen Ko, www.powenko.com"

from opencc import OpenCC
text1 = u"我去过清华大学和交通大学,打印机、光盘、内存。"
text2 = u"我去過清華大學和交通大學,印表機、光碟、記憶體。"

openCC = OpenCC('s2t')
line = openCC.convert(text1)
print("      " + text1)
print("s2t  :" + line)
line = openCC.set_conversion('s2twp')
line = openCC.convert(text1)
print("s2twp:" + line)

line = openCC.set_conversion('t2s')
line = openCC.convert(text2)
print("      " + text2)
print("t2s  :" + line)
line = openCC.set_conversion('tw2sp')
line = openCC.convert(text2)
print("tw2sp:" + line)
Exemplo n.º 5
0
        regex = re.compile(rf"{prefix}:(?:.*?,){{{r}}}(.*?\n)", re.I)
    return regex


if __name__ == "__main__":
    cc = OpenCC("t2s")
    type = (
        "t2s",
        "t2hk",
        "t2tw",
        "tw2s",
        "tw2sp",
        "hk2s",
        "s2hk",
        "s2t",
        "s2tw",
        "s2twp",
    )
    items = "\n".join([f"{x[0]}. {x[1]}" for x in enumerate(type)])
    n = input(
        f'WARNING: JAPANESE CHARACTER maybe affected!\n{items}\nInput number to select a convert type.\nInput nothing and enter to use "t2s" by default:'
    )
    try:
        if n != "":
            cc.set_conversion(int(n))
    except ValueError:
        print("Cancelled")
    else:
        path = input("Input dir you wanna batch edit:")
        func(path)
Exemplo n.º 6
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
from opencc import OpenCC

if __name__ == '__main__':
    if sys.version_info[0] < 3:
        print('Require Python3 to run')
        sys.exit(0)

    openCC = OpenCC()
    openCC.set_conversion('s2twp')
    # openCC = OpenCC('s2twp')

    words = '鼠标是一种很常見及常用的電腦输入设备,它可以对当前屏幕上的游标进行定位,并通过按键和滚轮装置对游标所经过位置的' \
            '屏幕元素进行操作。鼠标的鼻祖於1968年出现。美国科学家道格拉斯·恩格尔巴特(Douglas Englebart)在加利福尼亚制作了' \
            '第一只鼠标。'

    result = openCC.convert(words)
    print("{} \n\n==> \n\n{}".format(words, result))
Exemplo n.º 7
0
class OpenCCTest(unittest.TestCase):
    def setUp(self):
        # Unitialized convertor object
        self.openCC = OpenCC()
        # Constructor intitialized convertor object
        self.openCC2 = OpenCC('hk2s')

    def test_hk2s(self):
        self.openCC.set_conversion('hk2s')
        words = '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')

    def test_s2hk(self):
        self.openCC.set_conversion('s2hk')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香煙(英語:Cigarette),為煙草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2t(self):
        self.openCC.set_conversion('s2t')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2tw(self):
        self.openCC.set_conversion('s2tw')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),為菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2twp(self):
        self.openCC.set_conversion('s2twp')
        words = '香烟(英语:Cigarette),为烟草制品的一种。內存是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。')

    def test_t2hk(self):
        self.openCC.set_conversion('t2hk')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。')

    def test_t2s(self):
        self.openCC.set_conversion('t2s')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入装置。')

    def test_t2tw(self):
        self.openCC.set_conversion('t2tw')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words),
                         '香菸(英語:Cigarette),為菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_tw2s(self):
        self.openCC.set_conversion('tw2s')
        words = '香菸(英語:Cigarette),為菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入装置。')

    def test_tw2sp(self):
        self.openCC.set_conversion('tw2sp')
        words = '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。内存是一种很常见及常用的电脑输入设备。')

    # Code coverage and edge condition tests

    def test_unset(self):
        try:
            words = '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。'
            self.openCC.convert(words)
            #Following line not hit due to exception in conversion
            self.assertTrue(False)  # pragma: no cover
        except ValueError:
            pass

    def test_hk2s_convert2(self):
        self.openCC.set_conversion('hk2s')
        words = '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC2.convert(words),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')

    def test_multiple_conversions(self):
        self.openCC.set_conversion('hk2s')
        words_t = '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words_t),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')
        self.openCC.set_conversion('s2t')
        words_s = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words_s),
                         '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')
        self.openCC.set_conversion('hk2s')
        self.assertEqual(self.openCC.convert(words_t),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')
        self.openCC.set_conversion('hk2s')
        self.assertEqual(self.openCC.convert(words_t),
                         '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')

    def test_t2s_extended_unicode_1(self):
        self.openCC.set_conversion('t2s')
        words = '𠁞'
        self.assertEqual(self.openCC.convert(words), '𠀾')

    def test_t2s_extended_unicode_2(self):
        self.openCC.set_conversion('t2s')
        words = '𠁞種'
        self.assertEqual(self.openCC.convert(words), '𠀾种')

    def test_t2s_empty(self):
        self.openCC.set_conversion('t2s')
        words = ''
        self.assertEqual(self.openCC.convert(words), '')

    def test_t2s_choose_first_available(self):
        # TSCharacters.txt gives two choices for 儘: 尽 侭
        # The first one, 尽, is chosen
        self.openCC.set_conversion('t2s')
        words = '儘'
        self.assertEqual(self.openCC.convert(words), '尽')
Exemplo n.º 8
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import sys
from opencc import OpenCC


if __name__ == '__main__':
    if sys.version_info[0] < 3:
        print('Require Python3 to run')
        sys.exit(0)

    openCC = OpenCC()
    openCC.set_conversion('s2twp')
    # openCC = OpenCC('s2twp')

    words = '鼠标是一种很常見及常用的電腦输入设备,它可以对当前屏幕上的游标进行定位,并通过按键和滚轮装置对游标所经过位置的' \
            '屏幕元素进行操作。鼠标的鼻祖於1968年出现。美国科学家道格拉斯·恩格尔巴特(Douglas Englebart)在加利福尼亚制作了' \
            '第一只鼠标。'

    result = openCC.convert(words)
    print("{} \n\n==> \n\n{}".format(words, result))
Exemplo n.º 9
0
class OpenCCTest(unittest.TestCase):

    def setUp(self):
        self.openCC = OpenCC()

    def test_hk2s(self):
        self.openCC.set_conversion('hk2s')
        words = '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words), '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入设备。')

    def test_s2hk(self):
        self.openCC.set_conversion('s2hk')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words), '香煙(英語:Cigarette),為煙草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2t(self):
        self.openCC.set_conversion('s2t')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words), '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2tw(self):
        self.openCC.set_conversion('s2tw')
        words = '香烟(英语:Cigarette),为烟草制品的一种。鼠标是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words), '香菸(英語:Cigarette),為菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_s2twp(self):
        self.openCC.set_conversion('s2twp')
        words = '香烟(英语:Cigarette),为烟草制品的一种。內存是一种很常见及常用的电脑输入设备。'
        self.assertEqual(self.openCC.convert(words), '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。')

    def test_t2hk(self):
        self.openCC.set_conversion('t2hk')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words), '香煙(英語:Cigarette),為煙草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。')

    def test_t2s(self):
        self.openCC.set_conversion('t2s')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words), '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入装置。')

    def test_t2tw(self):
        self.openCC.set_conversion('t2tw')
        words = '香菸(英語:Cigarette),爲菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。'
        self.assertEqual(self.openCC.convert(words), '香菸(英語:Cigarette),為菸草製品的一種。鼠標是一種很常見及常用的電腦輸入設備。')

    def test_tw2s(self):
        self.openCC.set_conversion('tw2s')
        words = '香菸(英語:Cigarette),為菸草製品的一種。滑鼠是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words), '香烟(英语:Cigarette),为烟草制品的一种。滑鼠是一种很常见及常用的电脑输入装置。')

    def test_tw2sp(self):
        self.openCC.set_conversion('tw2sp')
        words = '香菸(英語:Cigarette),為菸草製品的一種。記憶體是一種很常見及常用的電腦輸入裝置。'
        self.assertEqual(self.openCC.convert(words), '香烟(英语:Cigarette),为烟草制品的一种。内存是一种很常见及常用的电脑输入设备。')
Exemplo n.º 10
0
# please refer to https://github.com/yichen0831/opencc-python
import csv
from opencc import OpenCC
import os
import re
import sqlite3

openCC = OpenCC()
openCC.set_conversion(
    's2twp'
)  # Simplified Chinese to Traditional Chinese (Taiwan standard, with phrases)

article_start_pattern = "<doc id="
article_id_pattern = re.compile("<doc id=\"(.+)\" url")
article_url_pattern = re.compile("url=\"(.+)\" title")
article_title_pattern = re.compile("title=\"(.+)\">")
article_text_pattern = re.compile("<doc id=\"(.+)\" url")

db_path = os.path.join(os.getcwd(), 'articles', 'wiki.db')
csv_path = os.path.join(os.getcwd(), 'articles', '_wiki.csv')
conn = sqlite3.connect(db_path)
cur = conn.cursor()

sql = "DELETE FROM Source"
cur.execute(sql)
conn.commit()

for item in range(0, 2):
    if item == 0:
        file_path = os.path.join(os.getcwd(), 'articles', 'wiki_00')
    else:
Exemplo n.º 11
0
#     ]
#
#     def parse(self, response):
#         for article in response.css('td.ccss'):
#             yield {
#                 'title': article.css('a::text').extract_first(),
#                 'link': article.css('a::attr("href")').extract_first(),
#             }

import os
import requests
from bs4 import BeautifulSoup
from opencc import OpenCC

cc = OpenCC('s2t')
cc.set_conversion('s2tw')

# aid = input('請輸入小說aid: ')
aid = '1787'
url = 'https://www.wenku8.net/modules/article/reader.php?aid=' + aid

r = requests.get(url)
r.encoding = "gbk"
soup = BeautifulSoup(r.text, 'html.parser')
title = cc.convert(soup.find("div", {"id": "title"}).getText())
tds = soup.find_all("td")

if os.path.exists(title) == False:
    os.mkdir(title)

for td in tds:
Exemplo n.º 12
0
        #print(spf[0],spf[1])
        ss = ss.replace(spf[0], spf[1])
    return ss

# 修改檔案名稱

def modify(root):
    # 每個檔案
    for txt in os.listdir('.'):
        ss = str(txt)
        ss=spec(ss)
        ss = openCC.convert(ss)
        os.rename(txt, ss)
        print(ss)

# 讀檔
f = open('specific.txt', encoding='utf8')
all_f = f.read()
linef = all_f.split('\n')
linefcou = len(linef)


os.chdir('book')  # 切換工作目錄
openCC = OpenCC()
openCC.set_conversion('s2t')  # 翻譯或轉譯 語言選擇
for root in os.listdir('.'):
    if(os.path.isdir(root)):
        os.chdir(root)  # 切進符合條件目錄
        modify(root)
        os.chdir('../')  # 切回原本工作目錄
os.system("pause")