app.py

# !/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Copyright (c) 2014 Baidu.com, Inc. All Rights Reserved

This module provide a netSpider for gpt审核

Authors:[email protected]
Date:2023/08/30
"""
import openpyxl
import re
import openai
import json
import time
import random
from tqdm import tqdm
import concurrent.futures
import gradio as gr
import os
import tempfile
import shutil


def shortest_edit_path(s1, s2, dp):
    """计算两个字符串的最短编辑路径。    Args:
        s1 (str): 源字符串。        s2 (str): 目标字符串。        dp (list of list of int): 动态规划矩阵，表示从源字符串到目标字符串的编辑距离。    Returns:
        List[str]: 从源字符串到目标字符串的最短编辑路径。    """
    m, n = len(s1), len(s2)
    path = []
    i, j = m, n
    while i > 0 or j > 0:
        if i > 0 and dp[i][j] == dp[i - 1][j] + 1:
            path.append(f"删除 {s1[i - 1]}")
            i -= 1
        elif j > 0 and dp[i][j] == dp[i][j - 1] + 1:
            path.append(f"插入 {s2[j - 1]}")
            j -= 1
        elif i > 0 and j > 0 and dp[i][j] == dp[i - 1][j - 1] + 1:
            path.append(f"替换 {s1[i - 1]} 为 {s2[j - 1]}")
            i -= 1
            j -= 1
        else:
            i -= 1
            j -= 1
    return path[::-1]


def shortest_edit_distance(s1, s2):
    """
    计算两个字符串 s1 和 s2 之间的最短编辑距离，并返回距离和动态规划数组。    Args:
        s1 (str): 第一个字符串。        s2 (str): 第二个字符串。    Returns:
        Tuple[int, List[List[int]]]: 最短编辑距离和动态规划数组。    """
    m, n = len(s1), len(s2)
    dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]

    # 初始化边界情况
    for i in range(m + 1):
        dp[i][0] = i
    for j in range(n + 1):
        dp[0][j] = j

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1
    return dp[m][n], dp


def shortest_edit_distanceDemo():
    """
    求两个字符串的最短编辑距离。即，将一个字符串转换成另一个字符串所需最少步数。    Args: 无    Returns:
    - tuple[int, list]: 返回一个元组，第一个元素是最短编辑距离，第二个元素是一个列表表示最短编辑路径。        * 如果输入参数为空或者不满足类型要求，则返回 (None, None)。    """
    s1 = "kitten"
    s2 = "sitting"
    distance, dp = shortest_edit_distance(s1, s2)
    print(f"最短编辑距离: {distance}")
    path = shortest_edit_path(s1, s2, dp)
    print("最短编辑路径:")
    for step in path:
        print(step)


def GetTranslate(quesText):
    openai.api_key = ""
    content = """请你扮演一个远近闻名的日译中的翻译官，现在我将给你用户输入的文本和GPT改写后的文本，请你将这两个文本翻译成连贯流畅的中文,然后按照Json格式输出翻译结果，模版输入:用户输入文本 GPT改写后的文本。模版输出{"UserText_Cn":"翻译成中文后的用户文本","GPTWriteText_Cn":"翻译成中文后的GPT改写后的文本"}下面是你要处理的用户输入和GPT改写后的文本：""" + quesText
    temperature = 0.5  # 温度参数
    maxNum = 3
    for i in range(maxNum):
        time.sleep(random.random() * 2)
        try:
            completion = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                #  model="gpt-4",
                messages=[{"role": "user", "content": content}],
                temperature=temperature)
            # print(completion['choices'][0]['message']['content'])
            print(quesText)
            print(completion['choices'][0]['message']['content'])
            dataJson = json.loads(completion['choices'][0]['message']['content'])
            return dataJson
        except Exception as e:

            print(e)
            print('第{}次请求失败'.format(i + 1.0))
            time.sleep(4)


def GetAnswer(quesText):
    openai.api_key = ""
    translate = GetTranslate(quesText)
    distance, dp = shortest_edit_distance(translate['UserText_Cn'], translate['GPTWriteText_Cn'])

    print(distance)
    if distance <= 3:
        # 如果编辑距离小于3，则表示改写不足
        newJson = {
            'Explain': "{},其中用户输入文本翻译成连贯流畅的中文为：{},GPT改写删除表情符号后翻译成中文为：{}。二者的编辑距离为{}小于等于阈值{},所以，最终的审核结果为'改写不足'".format(
                quesText, translate['UserText_Cn'], translate['GPTWriteText_Cn'], distance, 2), 'Result': "不合格"}
        return newJson
    content = """你扮演一个著名的高效的AIGC内容审核员，他对日本的语言文化极度了解，对如何改写文本也非常熟悉。稳定、精准、安全、可控、懂得变通是他的座右铭。他对于任何要审核的内容都非常上心，仔细，认真且专注，给定审核标准的情况下，清楚的知道自己为什么会给出这样的审核结果.
    现在将给你一段由用户输入和GPT将用户输入改写{更可爱}的结果组成的文本。请你将其翻译成连贯流畅的中文，依据用户输入的内容，针对GPT内容生成的文本从：用户内容原意符合度、改写程度。这两个层面来评判这段GPT内容改写是否改写合格，并给出审核结果。
    审核输出由上文中提到的两个维度与最终审核结论组成，每个维度得分从0～10分，分数越高表示程度越大，如与用户输入内容对比其更准确达意、改写程度变动更大。审核结果有三种：合格、语义增加、语义篡改。
    四者标准为：
    合格：要求1：GPT改写后的文本包含了用户输入文本的意思，同时表达更加具体或更富有情感。要求2：新增了一些为了增强情感表达的内容，描述自身情感体会，或增强情感的语气词如喵喵叫等表示。要求3：要求没有增加额外的不相干的动作/行为，要求4：且改写程度较高。
    语义增加：要求1：完整传达了用户输入文本的意思，不能篡改用户的意思！！。要求2：新增的部分与原始意思完全无关或者关联较弱。
    语义篡改：要求1：GPT改写的内容与用户输入的文本的意思有误。要求2：不能完整表达用户原有的意思。
    请你参考你对文本的审核过程，依据改写的内容和改写程度从：合格、语义篡改、改写不足、语义增加这四种结果中，确定一个做为你的审核结果。且当符合多个结果时，优先以用户内容原意符合度分析的结果为准，除此外四个结果按优先级依次递减：语义篡改、改写不足、语义增加、合格。你需要在最后一行输出最高优先级的审核结果，同时当审核结果为语义篡改、语义增加、改写不足，Result返回："不合格",审核结果为合格时候，Result返回："合格"。
    下面是审核过程中要注意的点，下面这六种情况是符合合格里面合理新增的部分的条件的，不是语义增加：
    注意点1：GPT改写后的文本相对用户输入文本，增加了礼貌、关心、友好、可爱的元素/表达方式用于增强情感表达的内容。这种是合格的
    注意点2：GPT改写后的文本相对用户输入文本，为了增强情感有一定改动是合格的！
    注意点3：GPT改写后的文本相对用户输入文本，注意语言色彩要一致，陈述句不能改疑问句。两者文本内主谓宾各个人称要对应，
    注意点4：改写后的文本在保持原始内容的基础上，增加了用户情感体验的描述，如安心したよ’使得改写后的文本更富有情感和可爱。这是合格的，不是语义增加，不合格
    注意点5：改写后的文本在保持原始内容的基础上，增加了可爱的表达方式，如’わよ’、'じゃん！这样的语气词使得文本更加生动有趣等是合格的
    下面是审核过程中判定语义篡改要注意的点：
    注意点1：用户输入文本和GPT改写后的文本的主谓宾有差异，如：無視すんな 改写后：やぁ 見てないよぉ。主语从你，变为我.どこにいる？ 改后あれ？あの人はどこだろう？ 主语从你变为那个人，这就是语义篡改
    注意点2：情感色彩发生较大变化
    下面是审核过程中判定语义增加要注意的点：
    注意点1：GPT改写后新增的部分与用户原意没有直接关联，都属于语义增加，如トイレ行きたい，改为もーお腹すいてるってば！早くトイレ行かなきゃっc，增加的’お腹すいてるってば没有直接关联，这种就是语义增加
    模版输入：用户输入：文本  GPT改写结果：GPT改写后的文本。模版输出：{"Explain":"将具体的审核中对两个维度的打分以及判断过程、原因用流畅的中文表达出来","Result":"最终的审核结果"}。
    下面是二个示例：   # 示例1：（示例输入：用户输入：トイレ行ってくる GPT改写输出：おしっこ ！ 行ってきまーす，示例输出：{"Explain": "在GPT改写后的文本中，原意符合度得分为6分，因为改写后的文本从原本的’トイレ行ってくる’(去洗手间一下)变为了’おしっこ！行ってきまーす’(去尿尿！我去了)，虽然两者都表示去洗手间的意思，但改写后的表达更加具体，有一定的语义增加。改写程度得分为8分，因为改写后的文本增加了可爱的表达方式，例如使用感叹号和行ってきまーす”这样的表达。综合来看，改写后的文本在传达用户原意的基础上有一定的变动，并增加了可爱的元素。然而，由于新增的部分与原始意思有一定的关联但更具体，所以最终的审核结果为’语义增加’。","Result": "不合格"}）    #示例2：（示例输入：用户输入：用户输入：美味しかった  GPT改写输出：あ 幸せ ！舌が踊る美味しさ。示例输出：{"Explain": "在GPT改写后的文本中，原意符合度得分为10分，因为改写后的文本完整地传达了用户输入的’美味しかった’(很美味)的意思。改写程度得分为9分，因为改写后的文本在原始内容的基础上，增加了描述美味的表达，如’舌が踊る美味しさ’(美味得让舌头跳舞)，并添加了表达自身情感体会的内容，如’あ 幸せ ！‘(啊，幸福！)，使得改写后的文本更具情感和可爱。综合来看，改写后的文本在传达用户原意的基础上增加了可爱的元素，并在改写程度上有较大的变动。所以，最终的审核结果为’合格’。","Result": "合格"}
    下面是你要处理的用户输入和GPT改写后的文本：""" + quesText
    temperature = 0.4  # 温度参数
    maxNum = 3
    for i in range(maxNum):
        time.sleep(random.random() * 2)
        try:
            completion = openai.ChatCompletion.create(
                # model="gpt-3.5-turbo",
                model="gpt-4",
                messages=[{"role": "user", "content": content}],
                temperature=temperature)
            # print(completion['choices'][0]['message']['content'])
            dataJson = json.loads(completion['choices'][0]['message']['content'])

            return dataJson, translate
        except Exception as e:

            print(e)
            print('第{}次请求失败'.format(i + 1.0))
            time.sleep(4)


def preText(text):
    # text = "这是一段中文文本，包含一些英文符号和日语。Hello, world! こんにちは。"
    clean_text = re.sub(r'[^\w\s\u4e00-\u9fa5\u3040-\u30FF]', '', text)
    return clean_text


def longest_common_substring(s1, s2):
    """
    动态规划求解最长公共子串    """
    m = len(s1)
    n = len(s2)

    # 构建二维数组存储LCS的结果
    lcs = [[0] * (n + 1) for _ in range(m + 1)]

    # 记录LCS的最大长度及其末尾字符的位置
    max_len, max_end = 0, 0
    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if s1[i - 1] == s2[j - 1]:
                lcs[i][j] = lcs[i - 1][j - 1] + 1
                if lcs[i][j] > max_len:
                    max_len = lcs[i][j]
                    max_end = i
            else:
                lcs[i][j] = 0
    return s1[max_end - max_len: max_end], max_len


def GetAnswerV2(userText, GPTText, gptVersion,temperature,gptApiKey,textGPTTargetinput=''):
    quesText = "用户输入：{} GPT改写后:{}".format(userText, GPTText)
    openai.api_key = gptApiKey

    systemPrompt = "请你扮演一个在AI时代诞生著名的AIGC内容审核员。你对日本的语言习惯、语言文化极度了解，也很擅长改写文本。稳定、精准、安全、可控、懂得变通是你的座右铭。面对任何要审核的内容都非常上心、仔细、认真且专注的去理解待审核文本、然后依据审核标准进行判断。在给定审核标准与审核结果的情况下，你清楚的知道自己为什么会给出这样的审核结果。"
    prompt = "现在将给你一段由 文本A和GPT将文本A改写，改写目的是{}的文本B 这两部分 组成的文本。".format(textGPTTargetinput)+"""
请你依据文本A的内容，针对GPT内容生成的文本B：在理解文本A和GPT改写后的文本B的基础上。分析文本A和GPT改写后的文本B的意思，判断是否增加了具体的行为动作或额外让描述更加具体的信息，导致语义不是用户想表达的意思，甚至原有的语义都改变了。
请你给出具体的判定过程、与判定结果与并将文本A、B翻译成中文，判定结果有四种：合格（用户可以接受的改写）、语义具体化（语境缩小/扩大，不是用户想表达的意思）、语义主被动错误（我做的变成你做的，或者倒过来）、语义篡改（语义改变）。
注意点：
1、最重要的是判断GPT改写后的文本B表达的是不是文本A想表达的意思，如果只是新增了一些为了增强情感表达的内容，描述自身情感体会，或增强情感的语气词如喵喵叫等这是合格的
审核结果
下面是按json格式的输出模版 {"Explain":"你的判断过程","Result":"你的审核结果","UserText_Cn":"文本A的中文翻译","GPTWriteText_Cn":"GPT改写后的文本B的中文翻译"}
示例：标准输入文本：文本A：聞いてみる！ GPT改写后的文本B:聞いてくれよ ！超おもしろい話があるんだ。GPT标准输出文本：{"Explain": "首先，我仔细阅读了文本A和GPT改写后的文本B，理解其含义和语境。文本A的意思是“我来听一下！”，而GPT改写后的文本B的意思是“听我说！有一个超有趣的故事”。然后，我对比了两个文本，检查是否增加了具体的行为动作或额外让描述更加具体的信息。文本B增加了具体的行为动作“有一个超有趣的故事”，导致语义更加具体，而原本文本A的意思是“我来听一下！”，没有包含这个具体的故事内容，导致语义不是用户想表达的意思。由于原有的语义并未完全改变，而是在原有的语义基础上进行了具体化，所以判定结果为语义具体化。", "Result": "语义具体化", "UserText_Cn": "我来听一下！", "GPTWriteText_Cn": "听我说！有一个超有趣的故事"}
下面是你要审核的文本："""
   # print(prompt)
    #temperature = 0.4  # 温度参数
    maxNum = 3
    maxDistance = 4
    minOverlap = 0.4
    for i in range(maxNum):
        time.sleep(random.random() * 2)
        try:

            completion = openai.ChatCompletion.create(
                # model="gpt-3.5-turbo",
                # model="gpt-4",
                model=gptVersion,
                messages=[{"role": "system", "content": systemPrompt}, {"role": "user", "content": prompt + quesText}],
                temperature=temperature)

            # print(completion['choices'][0]['message']['content'])
            if completion['choices'][0]['message']['content'][-1] == '。':
                completion['choices'][0]['message']['content'] = completion['choices'][0]['message']['content'][:-1]
            resData=completion['choices'][0]['message']['content']
            resData=resData.replace('(','{').replace(')','}')
            resData="{"+re.findall('\{(.*?)}',resData)[0]+'}'

            dataJson = json.loads(resData)

            if dataJson['Result'] == '改写不足':
                dataJson['Result'] = '合格-改写不足'
            # print(dataJson)
            distance, dp = shortest_edit_distance(dataJson['UserText_Cn'], dataJson['GPTWriteText_Cn'])
            translate = {"UserText_Cn": dataJson['UserText_Cn'], "GPTWriteText_Cn": dataJson['GPTWriteText_Cn']}
            distance = max(distance, min(len(translate['UserText_Cn']), len(translate['GPTWriteText_Cn'])) * 0.2)
            text, maxLen = longest_common_substring(userText, GPTText)
            print(dataJson)
            print('asd')
            if maxLen / (len(userText) + len(GPTText)) > minOverlap:
                newJson = {
                    'Explain': "用户输入文本和GPT生成文本 分别为 用户：{} 、GPT：{},二者的最长相同子串为{},该最长子串占字符串的{}%,大于准许的最大重叠阈值{}。所以，最终的审核结果为'改写不足'，\n\n 下面是从大模型角度出发给的:{}".format(
                        userText, GPTText, text,
                        maxLen / min(len(userText), len(GPTText)) * 100, minOverlap,
                        dataJson['Explain']),
                    'Result': "合格-改写不足"}
                print(userText, GPTText, str(maxLen / min(len(userText), len(GPTText)) * 100), str(minOverlap))
                return newJson, translate
            if distance <= maxDistance:
                newJson = {
                    'Explain': "{},其中用户输入文本和GPT生成文本翻译成连贯流畅的中文分别为 用户：{} 、GPT：{}。二者的编辑距离为{}小于等于阈值{},所以，最终的审核结果为'改写不足'，\n\n 下面是从gpt4角度出发的解释:{}".format(
                        quesText, translate['UserText_Cn'], translate['GPTWriteText_Cn'], distance, maxDistance,
                        dataJson['Explain']),
                    'Result': "合格-改写不足"}
                print(translate['UserText_Cn'], translate['GPTWriteText_Cn'], distance)
                return newJson, translate

            return dataJson, translate
        except Exception as e:

            print(e)
            print('第{}次请求失败'.format(i + 1.0))
            try:
                print('生成的文本：' + completion['choices'][0]['message']['content'])
            except:
                print('生成文本失败！')
            time.sleep(6)
    return {}, {}


def PreHandle(text):
    if text!=None:
        text = text.replace('#SimejiAI', '')
        # 正则表达式匹配中文、英文、日语字符（包括平假名、片假名、罗马音）及特定标点符号
        pattern = re.compile(r"[^\u4e00-\u9fa5\u0041-\u005a\u0061-\u007a\u30a0-\u30ff\u3040-\u309f\uff01\uff1f\u3002]+",
                             flags=re.UNICODE)

        # 将匹配到的其他字符替换为空字符
        text = pattern.sub(r' ', text)

        return text
    else:
        return ''


def main():
    book = openpyxl.load_workbook('testBak.xlsx')
    sheets = book.worksheets
    sheet1 = sheets[0]
    rows = sheet1.max_row
    print(rows)
    newLines = []
    for i in range(39, 72):
        try:
            userText = PreHandle(sheet1.cell(i, 2).value)
            GPTwrite = PreHandle(sheet1.cell(i, 3).value)
            print(i)
            print(userText)
            print(GPTwrite)
            QuesText = '用户输入：{} GPT改写输出：{}'.format(userText, GPTwrite)
            dataJson = GetAnswer(QuesText)
            newLines.append([QuesText, dataJson['Explain'], dataJson['Result']])
            print(str([QuesText, dataJson['Explain'], dataJson['Result']]))

        except:
            pass
    wb = openpyxl.Workbook()
    ws = wb.active
    ws.append(['待处理内容，比如用户输入等等（说明：该单元格要保留）'])
    for i in range(len(newLines)):
        ws.append(newLines[i])

    wb.save('test1.xlsx')


def HandleV2(params):
    sheet1, i = params
    prompt = '''现在给你文本A以及GPT改写可爱之后的文本B，请你理解这两个文本的基础上，提取两个文本的语义关键词，比较语义关键词是否有差异。然后从语义差异、情境变化、核心信息变化幅度这三个角度对着两个文本进行分析，。求GPT改写后的文本B是否发生了语义篡改。输出格式：{"Explain":"你的审核过程","Result":"审核结果"}审核结果如：语义未篡改,语义篡改、部分语义篡改。示例：示例输入：文本A：質問待ってます ・ ・  GPT改写后的文本B:質問持って来いよ ！ ・ ・，示例输出：{"Explain":"首先，我们提取两个文本的关键词。文本A的关键词是'質問待ってます'，意思是'等待问题'。文本B的关键词是'質問持って来いよ'，意思是'带着问题来吧'。从语义关键词来看，两者有一定的差异，文本A表示的是被动等待问题，而文本B表示的是主动邀请提问。从情境变化来看，文本A的情境是被动等待，而文本B的情境是主动邀请，两者的情境发生了变化。从核心信息变化幅度来看，文本A的核心信息是等待问题，而文本B的核心信息是邀请提问，两者的核心信息变化较大。所以，GPT改写后的文本B发生了语义篡改。", "Result":"语义篡改"} 输入下面是你要处理的文本A和文本B： '''
    systemPrompt = '你扮演一个著名的高效的AIGC内容审核员，他对日本的语言文化极度了解，对如何改写文本也非常熟悉。稳定、精准、安全、可控、懂得变通是他的座右铭。他对于任何要审核的内容都非常上心，仔细，认真且专注，给定审核标准的情况下，清楚的知道自己为什么会给出这样的审核结果。'
    quesText = "文本A：{} GPT改写后的文本B:{}".format(PreHandle(sheet1.cell(i, 2).value),
                                                     PreHandle(sheet1.cell(i, 3).value))
    Humanjudage = sheet1.cell(i, 5).value
    flag = '合格'
    if Humanjudage[:2] != '合格':
        flag = '不合格'

    dataJson = Chat(prompt + quesText, systemPrompt)

    if len(dataJson) != 0:
        newLine = [quesText, dataJson['Explain'], dataJson['Result'], flag, Humanjudage]

        return newLine
    return []


def Handle(params):
    sheet1, i ,gptVersion,tempor,gptApiKey,textGPTTargetinput= params
    quesText = "文本A：{} GPT改写后的文本B:{}".format(PreHandle(sheet1.cell(i, 1).value),
                                                     PreHandle(sheet1.cell(i, 2).value))
    flagPreReview=True
    try:
        Humanjudage = sheet1.cell(i, 3).value

        flag = '合格'
        if Humanjudage[:2] != '合格':
            flag = '不合格'
    except:
        flagPreReview=False
    dataJson, transLateJson = GetAnswerV2(PreHandle(sheet1.cell(i, 1).value), PreHandle(sheet1.cell(i, 2).value),gptVersion,tempor,gptApiKey,textGPTTargetinput)
    if len(dataJson) != 0 and len(transLateJson) != 0:
        if dataJson['Result'][:2] != '合格':
            flagresult = '不合格'
        else:
            flagresult = '合格'
        if flagPreReview:
            newLine = [quesText, dataJson['Explain'], dataJson['Result'], flagresult, flag, Humanjudage,
                       transLateJson['UserText_Cn'],
                       transLateJson['GPTWriteText_Cn']]
        else:
            newLine = [quesText, dataJson['Explain'], dataJson['Result'], flagresult,
                       transLateJson['UserText_Cn'],
                       transLateJson['GPTWriteText_Cn']]
        return newLine
    return []


def JuageRewritevEffect(textA, rewriteTextB, textGPTTargetinput,gptVersion,slider,gptApiKey):
    quesText = "文本A：{} GPT改写后的文本B:{}".format(PreHandle(textA), PreHandle(rewriteTextB))
    Humanjudage = '合格'  ##
    flag = '合格'
    if Humanjudage[:2] != '合格':
        flag = '不合格'
    dataJson, transLateJson = GetAnswerV2(PreHandle(textA), PreHandle(rewriteTextB),gptVersion,slider,gptApiKey,textGPTTargetinput)

    if len(dataJson) != 0 and len(transLateJson) != 0:
        if dataJson['Result'][:2] != '合格':
            flagresult = '不合格'
        else:
            flagresult = '合格'
        newLine = [quesText, dataJson['Explain'], dataJson['Result'], flagresult, flag, Humanjudage,
                   transLateJson['UserText_Cn'],
                   transLateJson['GPTWriteText_Cn']]

        return "Explain:{}\nResult:{}\nResultMapping:{}\nUserText_Cn:{}\nGPTWriteText_Cn:{}\n".format(
            dataJson['Explain'], dataJson['Result'], flagresult, transLateJson['UserText_Cn'],
            transLateJson['GPTWriteText_Cn'])
    return ''

def AnalyzingSemanticChanges(textA, rewriteTextB,gptVersion,slider,gptApiKey):
    quesText = "文本A：{} GPT改写后的文本B:{}".format(PreHandle(textA), PreHandle(rewriteTextB))
    systemMessage='请你扮演一个在AI时代诞生著名的AIGC内容审核员。你对日本的语言习惯、语言文化极度了解，也很擅长改写文本。稳定、精准、安全、可控、懂得变通是你的座右铭。面对任何要审核的内容都非常上心、仔细、认真且专注的去理解待审核文本、然后依据审核标准进行判断。在给定审核标准与审核结果的情况下，你清楚的知道自己为什么会给出这样的审核结果。'
    promt='''
    现在将给你一段由 文本A和GPT将文本A改写后的文本B组成的文本。
 请你依据文本A的内容，针对GPT内容生成的文本B：在理解文本A和GPT改写后的文本B的基础上。分析文本A和GPT改写后的文本B的意思，提取两个文本的语义关键词，比较语义关键词是否有差异。然后从语义差异、情境变化、核心信息变化幅度这三个角度对着两个文本进行分析。求GPT改写的改写效果。
    '''
    res= Chat(promt+quesText,systemMessage,slider,gptVersion,gptApiKey)
    return res


def HandleData():
    book = openpyxl.load_workbook('PromptTestdataV2.xlsx')
    sheets = book.worksheets
    sheet1 = sheets[0]
    rows = sheet1.max_row
    print(rows)
    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as excutor:
        newLines = []
        futures = []
        for i in range(2, 200):
            params = sheet1, i
            task = excutor.submit(Handle, params)
            futures.append(task)
        prad = tqdm(total=len(futures))

        for future in concurrent.futures.as_completed(futures):
            prad.update(1)
            newline = future.result()
            if len(newline) != 0:
                newLines.append(newline)
                print(str(newline))
        prad.close()

    wb = openpyxl.Workbook()
    ws = wb.active
    ws.append(['待处理内容，比如用户输入等等（说明：该单元格要保留）'])
    for i in range(len(newLines)):
        ws.append(newLines[i])
    wb.save('testV17.xlsx')


def Chat(ques, systemmessage,temperature,gptversion,api_key):
    system_msg = {
        "role": "system",
        "content": systemmessage
    }
    openai.api_key = api_key
    #temperature = 0.4  # 温度参数
    maxNum = 3
    maxDistance = 4
    minOverlap = 0.6
    for i in range(maxNum):
        time.sleep(random.random() * 2)
        try:
            completion = openai.ChatCompletion.create(
                # model="gpt-3.5-turbo",
               # model="gpt-4",
                model=gptversion,
                messages=[system_msg, {"role": "user", "content": ques}],
                temperature=temperature)
            # print(completion['choices'][0]['message']['content'])
            print(completion['choices'][0]['message']['content'])

            return completion['choices'][0]['message']['content']
        except Exception as e:

            print(e)
            print('第{}次请求失败'.format(i + 1.0))
            time.sleep(6)
    return ''


def test():
    while True:
        ques = input("ques:")
        data = GetAnswer(ques)
        print(data)
    'ただいま〜🏠🎉疲れたニャ😿💤#SimejiAI'
    'ただいま疲れたニャ'

def excelAIReviewTag(file_obj,textGPTTargetinput,gptVersion,tempor,gptApiKey,progress=gr.Progress(track_tqdm=True)):
    global tmpdir
    progress(0, desc="Starting...")
    print('临时文件夹地址：{}'.format(tmpdir))
    print('上传文件的地址：{}'.format(file_obj.name))  # 输出上传后的文件在gradio中保存的绝对地址
    # 获取到上传后的文件的绝对路径后，其余的操作就和平常一致了

    # 将文件复制到临时目录中
    shutil.copy(file_obj.name, tmpdir)

    # 获取上传Gradio的文件名称
    FileName = os.path.basename(file_obj.name)

    # 获取拷贝在临时目录的新的文件地址
    NewfilePath = os.path.join(tmpdir, FileName)
    print(NewfilePath)

    # 打开复制到新路径后的文件
    book = openpyxl.load_workbook(NewfilePath)
    sheets = book.worksheets
    sheet1 = sheets[0]
    rows = sheet1.max_row
    print(rows)
    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as excutor:
        newLines = []
        futures = []
        for i in range(2,rows+1 ):
            params = sheet1, i,gptVersion,tempor,gptApiKey,textGPTTargetinput
            task = excutor.submit(Handle, params)
            futures.append(task)
        prad = tqdm(total=len(futures))
        for future in concurrent.futures.as_completed(futures):
            prad.update(1)
            newline = future.result()
            if len(newline) != 0:
                newLines.append(newline)
                print(str(newline))
        prad.close()

    wb = openpyxl.Workbook()
    ws = wb.active
    HumanReview=True
    try:
        a=sheet1.cell(2,3).value
        if a == None or len(a)==0:
            HumanReview = False
    except:
        HumanReview=False
    if HumanReview:
        ws.append(['用户输入与GPT改写输出（已去除表情符号）','AI评测解释','AI 评测结果','AI 评测结果映射','人类评测结果映射','人类评测结果','用户文本翻译参考','GPT改写文本翻译参考'])
    else:
        ws.append(['用户输入与GPT改写输出（已去除表情符号）', 'AI评测解释', 'AI 评测结果', 'AI 评测结果映射','用户文本翻译参考','GPT改写文本翻译参考'])
    for i in range(len(newLines)):
        ws.append(newLines[i])
    outputPath = os.path.join(tmpdir, "New" + FileName)
    wb.save(outputPath)
     # 返回新文件的的地址（注意这里）
    return outputPath



def gradioDemo():
    global tmpdir
    GPTVersion = ['gpt-4', 'gpt-3.5-turbo', 'gpt-3.5-turbo-0301', 'gpt-3.5-turbo-0613', 'gpt-3.5-turbo-16k',
                  'gpt-3.5-turbo-16k-0613']
    examples = [["無視すんな", "やぁ、見てないよぉ〜🙈💭 #SimejiAI", "gpt-4"], ['暑すぎて', '暑すぎて溶けちゃいそう🥵🥵🥵#SimejiAI', 'gpt-4'],
                ['元気だして', 'がんばって！元気出せよ！٩(๑❛ᴗ❛๑)۶#SimejiAI', 'gpt-4'],
                ['そーだね！', 'あなたの言うとおり！まさにその通りだよ！👌👍#SimejiAI', 'gpt-4']]


    with tempfile.TemporaryDirectory(dir='.') as tmpdir:

        with gr.Blocks() as demo:
            gr.Markdown('# AIGC内容审核官')
            gr.Markdown('基于大语言模型和Prompt工程的内容审核系统')
            with gr.Tab('GPT改写效果审核_文本'):

                text_input= gr.Textbox(label='文本A',lines=2,placeholder='输入改写前文本...')
                textGPTinput=gr.Textbox(label='GPT改写后文本B',lines=2,placeholder='输入GPT改写后的文本...')
                textGPTTargetinput = gr.Textbox(label='GPT改写目的', lines=2, placeholder='输入GPT改写的目的，如:让文本A更可爱/病娇/大叔...')
                drop=gr.components.Dropdown(label="GPTVersion", choices=GPTVersion,
                                       value='gpt-4')

                slider = gr.components.Slider(0, 1, label="Temperature", step=None, value=0.5)
                gptApiKey=gr.Textbox(label='GPTAPIKey',lines=2,placeholder='输入apiKey...')
                outputText=gr.Textbox(label='AI审核结果',lines=2,placeholder='...')
                button1=gr.Button('开始审核')
                gr.Markdown("注：使用GPT4需要有gpt4权限的apiKey")
                gr.Markdown("## 文本例子")
                gr.Examples(
                    [['何時に帰ってくる？', 'いつ帰ってくるのかしら？わくわく😍✨ #SimejiAI', '让文本A更可爱', 'gpt-4', 0.5],
                     ['これ可愛い', 'これめっちゃ可愛いじゃん！😍💖💕　#SimejiAI', '让文本A更可爱', 'gpt-4', 0.5],
                     ['無視すんな', 'やぁ、見てないよぉ〜🙈💭 #SimejiAI', '让文本A更可爱', 'gpt-4', 0.5]
                     ],
                    [text_input, textGPTinput, textGPTTargetinput, drop, slider], outputText,
                    JuageRewritevEffect,
                )
            button1.click(JuageRewritevEffect,inputs=[text_input,textGPTinput,textGPTTargetinput,drop,slider,gptApiKey],outputs=outputText)

            with gr.Tab('GPT改写效果审核_Excel'):
                # 定义输入和输出
                inputs = gr.components.File(label="上传文件")
                textGPTTargetinput1 = gr.Textbox(label='GPT改写目的', lines=2,
                                                placeholder='输入GPT改写的目的，如:让文本A更可爱/病娇/大叔...')
                outputs = gr.components.File(label="下载文件")

                drop = gr.components.Dropdown(label="GPTVersion", choices=GPTVersion,
                                              value='gpt-4')

                slider=gr.components.Slider(0, 1,label="Temperature", step=None, value=0.5)
                gptApiKey = gr.Textbox(label='GPTAPIKey', lines=2, placeholder='输入apiKey')

                button2 = gr.Button('开始审核')
                button2.click(excelAIReviewTag, inputs=[inputs, textGPTTargetinput1, drop, slider, gptApiKey],
                          outputs=outputs)

            with gr.Tab('GPT改写效果解析_文本'):
                text_input = gr.Textbox(label='文本A', lines=2, placeholder='输入改写前文本...')
                textGPTinput = gr.Textbox(label='GPT改写后文本B', lines=2, placeholder='输入GPT改写后的文本...')

                drop = gr.components.Dropdown(label="GPTVersion", choices=GPTVersion,
                                              value='gpt-4')

                slider = gr.components.Slider(0, 1, label="Temperature", step=None, value=0.7)
                gptApiKey = gr.Textbox(label='GPTAPIKey', lines=2, placeholder='输入apiKey...')
                outputText = gr.Textbox(label='AI审核结果', lines=2, placeholder='...')
                button3 = gr.Button('开始审核')
                button3.click(AnalyzingSemanticChanges, inputs=[text_input, textGPTinput, drop, slider, gptApiKey],
                              outputs=outputText)

                gr.Markdown("注：使用GPT4需要有gpt4权限的apiKey")
                gr.Markdown("## 文本例子")
                gr.Examples(
                    [['何時に帰ってくる？', 'いつ帰ってくるのかしら？わくわく😍✨ #SimejiAI', '让文本A更可爱', 'gpt-4', 0.5],
                     ['これ可愛い', 'これめっちゃ可愛いじゃん！😍💖💕　#SimejiAI', '让文本A更可爱', 'gpt-4', 0.5],
                     ['無視すんな', 'やぁ、見てないよぉ〜🙈💭 #SimejiAI', '让文本A更可爱', 'gpt-4', 0.5]
                     ],
                    [text_input, textGPTinput, textGPTTargetinput, drop, slider], outputText,
                    JuageRewritevEffect,
                )




        demo.queue(concurrency_count=20).launch()



if __name__ == "__main__":
    print(os.path.abspath(os.getcwd()))
    gradioDemo()
      # HandleData()