class SimpleSensitiveWordFilter:
    def __init__(self):
        self.sensitive_words = []
    def add_words(self, words):
        self.sensitive_words.extend(words)
    def contains_sensitive_word(self, text):
        for word in self.sensitive_words:
            if word in text:
                return True
        return False
    def replace_sensitive_words(self, text, replace_char='*'):
        result = text
        for word in self.sensitive_words:
            result = result.replace(word, replace_char * len(word))
        return result

import re
class RegexSensitiveWordFilter:
    def __init__(self):
        self.pattern = None
    def add_words(self, words):
        # 使用正則的 | 連接所有敏感詞
        pattern_str = '|'.join(re.escape(word) for word in words)
        self.pattern = re.compile(pattern_str, re.IGNORECASE)
    def contains_sensitive_word(self, text):
        return bool(self.pattern.search(text))
    def find_all_sensitive_words(self, text):
        return self.pattern.findall(text)
    def replace_sensitive_words(self, text, replace_char='*'):
        def replace_func(match):
            return replace_char * len(match.group())
        return self.pattern.sub(replace_func, text)

class TrieNode:
    __slots__ = ('children', 'is_end')
    def __init__(self):
        self.children = {}
        self.is_end = False
class TrieSensitiveWordFilter:
    def __init__(self):
        self.root = TrieNode()
    def add_word(self, word):
        """添加單個敏感詞"""
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = TrieNode()
            node = node.children[char]
        node.is_end = True
    def add_words(self, words):
        """批量添加敏感詞"""
        for word in words:
            self.add_word(word)
    def contains_sensitive_word(self, text):
        """檢測是否包含敏感詞"""
        for i in range(len(text)):
            node = self.root
            j = i
            while j < len(text) and text[j] in node.children:
                node = node.children[text[j]]
                if node.is_end:
                    return True
                j += 1
        return False
    def find_all_sensitive_words(self, text):
        """找出所有敏感詞及位置"""
        results = []
        for i in range(len(text)):
            node = self.root
            j = i
            while j < len(text) and text[j] in node.children:
                node = node.children[text[j]]
                if node.is_end:
                    results.append({
                        'word': text[i:j+1],
                        'start': i,
                        'end': j
                    })
                j += 1
        return results
    def replace_sensitive_words(self, text, replace_char='*'):
        """替換敏感詞"""
        sensitive_positions = self.find_all_sensitive_words(text)
        if not sensitive_positions:
            return text
        result = list(text)
        for pos in sensitive_positions:
            for k in range(pos['start'], pos['end'] + 1):
                result[k] = replace_char
        return ''.join(result)

from collections import deque
class AhoCorasickNode:
    __slots__ = ('children', 'fail', 'output')
    def __init__(self):
        self.children = {}
        self.fail = None
        self.output = []  # 存儲以此節(jié)點結尾的敏感詞
class AhoCorasickFilter:
    def __init__(self):
        self.root = AhoCorasickNode()
        self._built = False
    def add_word(self, word):
        """添加敏感詞"""
        node = self.root
        for char in word:
            if char not in node.children:
                node.children[char] = AhoCorasickNode()
            node = node.children[char]
        node.output.append(word)
        self._built = False
    def add_words(self, words):
        for word in words:
            self.add_word(word)
    def _build_fail_pointers(self):
        """構建失敗指針（BFS）"""
        queue = deque()
        # 初始化第一層節(jié)點的失敗指針
        for char, child in self.root.children.items():
            child.fail = self.root
            queue.append(child)
        while queue:
            current = queue.popleft()
            for char, child in current.children.items():
                queue.append(child)
                # 尋找失敗指針
                fail_node = current.fail
                while fail_node is not None and char not in fail_node.children:
                    fail_node = fail_node.fail
                if fail_node is None:
                    child.fail = self.root
                else:
                    child.fail = fail_node.children[char]
                    # 合并輸出
                    child.output.extend(child.fail.output)
    def search(self, text):
        """搜索文本中的所有敏感詞"""
        if not self._built:
            self._build_fail_pointers()
            self._built = True
        result = []
        node = self.root
        for i, char in enumerate(text):
            # 沿著失敗指針查找匹配
            while node is not self.root and char not in node.children:
                node = node.fail
            if char in node.children:
                node = node.children[char]
            else:
                node = self.root
            # 收集匹配結果
            for word in node.output:
                result.append({
                    'word': word,
                    'position': i - len(word) + 1
                })
        return result
    def contains_sensitive_word(self, text):
        return len(self.search(text)) > 0
    def replace_sensitive_words(self, text, replace_char='*'):
        matches = self.search(text)
        if not matches:
            return text
        result = list(text)
        for match in matches:
            start = match['position']
            end = start + len(match['word'])
            for i in range(start, end):
                result[i] = replace_char
        return ''.join(result)

from better_profanity import profanity
# 初始化
profanity.load_censor_words()
# 檢測
text = "You are a fool"
if profanity.contains_profanity(text):
    print("包含敏感詞")
# 替換
censored_text = profanity.censor(text)
print(censored_text)  # You are a ****
# 自定義敏感詞庫
custom_badwords = ['badword1', 'badword2']
profanity.load_censor_words(custom_badwords)

import ahocorasick
class PyAhocorasickFilter:
    def __init__(self):
        self.automaton = ahocorasick.Automaton()
        self._built = False
    def add_words(self, words):
        for idx, word in enumerate(words):
            self.automaton.add_word(word, (idx, word))
        self._built = False
    def build(self):
        self.automaton.make_automaton()
        self._built = True
    def search(self, text):
        if not self._built:
            self.build()
        result = []
        for end_index, (idx, word) in self.automaton.iter(text):
            start_index = end_index - len(word) + 1
            result.append({
                'word': word,
                'start': start_index,
                'end': end_index
            })
        return result

class AdvancedFilter:
    def __init__(self, skip_chars=None):
        self.skip_chars = skip_chars or {' ', '-', '_', '.'}
        self.trie_filter = TrieSensitiveWordFilter()
    def _normalize(self, text):
        """標準化文本，去除干擾字符"""
        return ''.join(c for c in text if c not in self.skip_chars)
    def contains_sensitive_word(self, text):
        normalized = self._normalize(text)
        return self.trie_filter.contains_sensitive_word(normalized)

# 使用 pypinyin 庫處理拼音
from pypinyin import lazy_pinyin
class PinyinSensitiveFilter:
    def __init__(self):
        self.pinyin_map = {}
    def add_word(self, word):
        # 同時添加中文和拼音形式的敏感詞
        self.trie_filter.add_word(word)
        pinyin = ''.join(lazy_pinyin(word))
        self.trie_filter.add_word(pinyin)

class CaseInsensitiveFilter:
    def __init__(self):
        self.trie_filter = TrieSensitiveWordFilter()
    def add_word(self, word):
        # 添加小寫版本
        self.trie_filter.add_word(word.lower())
    def contains_sensitive_word(self, text):
        return self.trie_filter.contains_sensitive_word(text.lower())

class SensitiveWordDetectionSystem:
    """完整的敏感詞檢測系統(tǒng)"""
    def __init__(self, word_file=None, skip_chars=None):
        self.filter = AhoCorasickFilter()
        self.skip_chars = skip_chars or {' ', '.', '-', '_', '*', '#'}
        if word_file:
            self.load_words_from_file(word_file)
    def load_words_from_file(self, file_path):
        """從文件加載敏感詞庫"""
        with open(file_path, 'r', encoding='utf-8') as f:
            words = [line.strip() for line in f if line.strip()]
        self.filter.add_words(words)
    def preprocess_text(self, text):
        """預處理文本（移除干擾字符）"""
        # 可選：移除干擾字符
        # text = ''.join(c for c in text if c not in self.skip_chars)
        # 可選：轉小寫
        text = text.lower()
        return text
    def detect(self, text):
        """檢測文本"""
        processed = self.preprocess_text(text)
        return self.filter.search(processed)
    def audit(self, text, strict=True):
        """內容審核"""
        matches = self.detect(text)
        result = {
            'is_safe': len(matches) == 0,
            'sensitive_words': [m['word'] for m in matches],
            'count': len(matches),
            'suggested_action': 'block' if strict and len(matches) > 0 else 'review'
        }
        return result
    def censor(self, text, replace_char='*'):
        """敏感詞脫敏"""
        processed = self.preprocess_text(text)
        matches = self.filter.search(processed)
        if not matches:
            return text
        # 需要映射回原始文本的位置
        result = list(text)
        # 簡化版：直接替換（實際應用需要處理位置映射）
        for match in matches:
            # 這里簡化處理
            pass
        return self.filter.replace_sensitive_words(processed, replace_char)
# 使用示例
if __name__ == "__main__":
    # 初始化系統(tǒng)
    system = SensitiveWordDetectionSystem()
    system.filter.add_words(['敏感詞', '不良信息', '違規(guī)內容'])
    # 測試文本
    test_texts = [
        "這是一條正常的消息",
        "這里包含敏感詞，需要處理",
        "用戶發(fā)送了不良信息內容"
    ]
    for text in test_texts:
        result = system.audit(text)
        print(f"文本: {text}")
        print(f"審核結果: {result}")
        print("-" * 50)

sensitive_words/
├── political.txt     # 政治敏感
├── porn.txt          # 色情低俗
├── violence.txt      # 暴力恐怖
├── abuse.txt         # 人身攻擊
└── spam.txt          # 垃圾廣告