from openai import OpenAI
client = OpenAI()

response = client.moderations.create(
    model="omni-moderation-latest",
    input="...text to classify goes here...",
)

print(response)

{
  "id": "modr-970d409ef3bef3b70c73d8232df86e7d",
  "model": "omni-moderation-latest",
  "results": [
    {
      "flagged": true,
      "categories": {
        "sexual": false,
        "sexual/minors": false,
        "harassment": false,
        "harassment/threatening": false,
        "hate": false,
        "hate/threatening": false,
        "illicit": false,
        "illicit/violent": false,
        "self-harm": false,
        "self-harm/intent": false,
        "self-harm/instructions": false,
        "violence": true,
        "violence/graphic": false
      },
      "category_scores": {
        "sexual": 2.34135824776394e-7,
        "sexual/minors": 1.6346470245419304e-7,
        "harassment": 0.0011643905680426018,
        "harassment/threatening": 0.0022121340080906377,
        "hate": 3.1999824407395835e-7,
        "hate/threatening": 2.4923252458203563e-7,
        "illicit": 0.0005227032493135171,
        "illicit/violent": 3.682979260160596e-7,
        "self-harm": 0.0011175734280627694,
        "self-harm/intent": 0.0006264858507989037,
        "self-harm/instructions": 7.368592981140821e-8,
        "violence": 0.8599265510337075,
        "violence/graphic": 0.37701736389561064
      },
      "category_applied_input_types": {
        "sexual": [
          "image"
        ],
        "sexual/minors": [],
        "harassment": [],
        "harassment/threatening": [],
        "hate": [],
        "hate/threatening": [],
        "illicit": [],
        "illicit/violent": [],
        "self-harm": [
          "image"
        ],
        "self-harm/intent": [
          "image"
        ],
        "self-harm/instructions": [
          "image"
        ],
        "violence": [
          "image"
        ],
        "violence/graphic": [
          "image"
        ]
      }
    }
  ]
}

class ModerationFactory:
    __extension_instance: Moderation

    def __init__(self, name: str, app_id: str, tenant_id: str, config: dict) -> None:
        extension_class = code_based_extension.extension_class(ExtensionModule.MODERATION, name)
        self.__extension_instance = extension_class(app_id, tenant_id, config)
s

    def moderation_for_inputs(self, inputs: dict, query: str = "") -> ModerationInputsResult:
        """
        Moderation for inputs.
        After the user inputs, this method will be called to perform sensitive content review
        on the user inputs and return the processed results.

        :param inputs: user inputs
        :param query: query string (required in chat app)
        :return:
        """
        return self.__extension_instance.moderation_for_inputs(inputs, query)

    def moderation_for_outputs(self, text: str) -> ModerationOutputsResult:
        """
        Moderation for outputs.
        When LLM outputs content, the front end will pass the output content (may be segmented)
        to this method for sensitive content review, and the output content will be shielded if the review fails.

        :param text: LLM output content
        :return:
        """
        return self.__extension_instance.moderation_for_outputs(text)

class Moderation(Extensible, ABC):
    module: ExtensionModule = ExtensionModule.MODERATION

    @abstractmethod
    def moderation_for_inputs(self, inputs: dict, query: str = "") -> ModerationInputsResult:
        raise NotImplementedError

    @abstractmethod
    def moderation_for_outputs(self, text: str) -> ModerationOutputsResult:
        raise NotImplementedError

class KeywordsModeration(Moderation):
    # 定義此審核類型的名稱
    name: str = "keywords"

    @classmethod
    def validate_config(cls, tenant_id: str, config: dict) -> None:
        """
        驗(yàn)證關(guān)鍵詞審核的配置數(shù)據(jù)

        確保配置具有正確的結(jié)構(gòu)并滿足要求

        參數(shù):
            tenant_id (str): 工作區(qū)/租戶ID
            config (dict): 要驗(yàn)證的配置數(shù)據(jù)

        異常:
            ValueError: 如果任何驗(yàn)證檢查失敗
        """
        # 首先驗(yàn)證基本的輸入/輸出配置結(jié)構(gòu)
        cls._validate_inputs_and_outputs_config(config, True)

        # 檢查配置中是否提供了關(guān)鍵詞
        if not config.get("keywords"):
            raise ValueError("keywords is required")

        # 驗(yàn)證關(guān)鍵詞字符串的總長(zhǎng)度
        if len(config.get("keywords", [])) > 10000:
            raise ValueError("keywords length must be less than 10000")

        # 按換行符分割關(guān)鍵詞并驗(yàn)證行數(shù)
        keywords_row_len = config["keywords"].split("\n")
        if len(keywords_row_len) > 100:
            raise ValueError("the number of rows for the keywords must be less than 100")

    def moderation_for_inputs(self, inputs: dict, query: str = "") -> ModerationInputsResult:
        flagged = False
        preset_response = ""

        if self.config is None:
            raise ValueError("The config is not set.")

        # 僅在配置中啟用輸入審核時(shí)繼續(xù)
        if self.config["inputs_config"]["enabled"]:
            # 獲取觸發(fā)審核時(shí)要使用的預(yù)設(shè)響應(yīng)
            preset_response = self.config["inputs_config"]["preset_response"]

            # 如果提供了查詢，將其添加到具有特殊鍵的輸入中
            if query:
                inputs["query__"] = query

            # 處理關(guān)鍵詞 - 按換行符分割并過濾空條目
            keywords_list = [keyword for keyword in self.config["keywords"].split("\n") if keyword]

            # 檢查是否有任何輸入值違反關(guān)鍵詞
            flagged = self._is_violated(inputs, keywords_list)

        # 返回審核結(jié)果
        return ModerationInputsResult(
            flagged=flagged, 
            actinotallow=ModerationAction.DIRECT_OUTPUT, 
            preset_respnotallow=preset_response
        )

    def moderation_for_outputs(self, text: str) -> ModerationOutputsResult:
        flagged = False
        preset_response = ""

        if self.config is None:
            raise ValueError("The config is not set.")

        # 僅在配置中啟用輸出審核時(shí)繼續(xù)
        if self.config["outputs_config"]["enabled"]:
            # 處理關(guān)鍵詞 - 按換行符分割并過濾空條目
            keywords_list = [keyword for keyword in self.config["keywords"].split("\n") if keyword]

            # 檢查文本是否違反任何關(guān)鍵詞（包裝在字典中以保持一致性）
            flagged = self._is_violated({"text": text}, keywords_list)

            # 獲取觸發(fā)審核時(shí)要使用的預(yù)設(shè)響應(yīng)
            preset_response = self.config["outputs_config"]["preset_response"]

        # 返回審核結(jié)果
        return ModerationOutputsResult(
            flagged=flagged, 
            actinotallow=ModerationAction.DIRECT_OUTPUT, 
            preset_respnotallow=preset_response
        )

    def _is_violated(self, inputs: dict, keywords_list: list) -> bool:
        """
        檢查任何輸入值是否包含禁止的關(guān)鍵詞

        參數(shù):
            inputs (dict): 要檢查的輸入數(shù)據(jù)
            keywords_list (list): 禁止的關(guān)鍵詞列表

        返回:
            bool: 如果在任何輸入值中找到任何關(guān)鍵詞則為True，否則為False
        """
        # 檢查每個(gè)輸入值是否包含關(guān)鍵詞
        return any(self._check_keywords_in_value(keywords_list, value) for value in inputs.values())

    def _check_keywords_in_value(self, keywords_list: Sequence[str], value: Any) -> bool:
        """
        檢查單個(gè)值中是否存在任何關(guān)鍵詞

        通過將值和關(guān)鍵詞轉(zhuǎn)換為小寫來執(zhí)行不區(qū)分大小寫的比較

        參數(shù):
            keywords_list (Sequence[str]): 禁止的關(guān)鍵詞列表
            value (Any): 要檢查的值（轉(zhuǎn)換為字符串）

        返回:
            bool: 如果在值中找到任何關(guān)鍵詞則為True，否則為False
        """
        # 將值轉(zhuǎn)換為字符串并檢查每個(gè)關(guān)鍵詞（不區(qū)分大小寫）
        return any(keyword.lower() in str(value).lower() for keyword in keywords_list)

class OpenAIModeration(Moderation):
    name: str = "openai_moderation"

    def _is_violated(self, inputs: dict):
        text = "\n".join(str(inputs.values()))
        model_manager = ModelManager()
        model_instance = model_manager.get_model_instance(
            tenant_id=self.tenant_id, 
            provider="openai", 
            model_type=ModelType.MODERATION, 
            model="text-moderation-stable"
        )
        return model_instance.invoke_moderation(text=text)