badwords-py 2.1.0__tar.gz

badwords_py-2.1.0/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 FlacSy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so.
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

badwords_py-2.1.0/PKG-INFO

@@ -0,0 +1,201 @@
+Metadata-Version: 2.4
+Name: badwords-py
+Version: 2.1.0
+Summary: This is a library for effective moderation of content.
+Author-email: iamlostshe <vanamelcikov7275@gmail.com>, FlacSy <flacsy.x@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/FlacSy/badwords
+Project-URL: Repository, https://github.com/FlacSy/badwords.git
+Project-URL: Issues, https://github.com/FlacSy/badwords/issues
+Keywords: moderation,content filtering,obscenity detection,mood analysis,image moderation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+<div align="center">
+
+  # 🚫 BadWords
+
+  **High-performance profanity filter for Python with multilingual support and evasion detection.**
+
+  [![Python Version](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue?style=flat-square)](https://www.python.org/)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+  [![Build Status](https://img.shields.io/badge/build-passing-brightgreen?style=flat-square)](#)
+  [![Downloads](https://img.shields.io/pypi/dm/bad-words?style=flat-square&color=orange)](https://pypi.org/project/bad-words/)
+  
+  [Installation](#-installation) • [Quick Start](#-quick-start) • [Supported Languages](#-supported-languages) • [Advanced Evasion Detection](#-advanced-evasion-detection)
+
+</div>
+
+---
+
+## 📖 Description
+
+`BadWords` is a sophisticated profanity filtering library designed to clean up user-generated content. Unlike simple keyword matching, it uses **similarity scoring**, **homoglyph detection**, and **transliteration** to catch even the most cleverly disguised insults.
+
+## 📦 Installation
+
+### Requirements
+- **Recommended:** Python 3.13
+- **Minimum:** Python 3.10+
+
+### Install via GitHub
+```bash
+pip install git+[https://github.com/FlacSy/badwords.git](https://github.com/FlacSy/badwords.git)
+
+```
+
+### Install via PyPI
+```bash
+pip install badwords-py
+```
+
+---
+
+## ⚡ Quick Start
+
+### Basic Initialization
+
+```python
+from badwords import ProfanityFilter
+
+# Initialize filter
+p = ProfanityFilter()
+
+# Load specific languages (e.g., English and Russian)
+p.init(languages=["en", "ru"])
+
+# Or load ALL 26+ supported languages
+p.init()
+
+```
+
+### Checking and Filtering Text
+
+```python
+text = "Some very b4d text here"
+
+# 1. Simple check (Returns Boolean)
+is_bad = p.filter_text(text)
+print(is_bad) # True
+
+# 2. Censoring text (Returns String)
+clean_text = p.filter_text(text, replace_character="*")
+print(clean_text) # "Some very *** text here"
+
+```
+
+---
+
+## 🛠 Methods & API
+
+### `filter_text(text, match_threshold=0.8, replace_character=None)`
+
+The core method of the library.
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `text` | `str` | Required | Input text to check. |
+| `match_threshold` | `float` | `0.8` | Similarity threshold (1.0 = exact match, 0.7 = aggressive). |
+| `replace_character` | `str/None` | `None` | If provided, returns censored string. If None, returns bool. |
+
+> [!WARNING]
+> **Performance Tip:** Using `match_threshold < 1.0` enables fuzzy matching which is slower. Use `1.0` for high-traffic real-time filtering, or `0.95` for a good balance.
+
+---
+
+## 🧩 Advanced Evasion Detection
+
+Standard filters are easy to bypass. `BadWords` is built to detect:
+
+* **Homoglyphs:** Detects `hеllo` (using Cyrillic 'е') or `h4llo` (numbers).
+* **Transliteration:** Automatically handles mapping between Cyrillic and Latin alphabets.
+* **Normalization:** Strips diacritics, special characters, and decorative Unicode symbols.
+* **Similarity Analysis:** Uses fuzzy matching to find words with deliberate typos.
+
+### Examples of detected evasions:
+
+```python
+_filter.filter_text("hеllо")  # Mixed alphabets (Cyrillic + Latin) -> DETECTED
+_filter.filter_text("h3ll0")  # Character substitution -> DETECTED
+_filter.filter_text("h⍺llo")  # Mathematical/Greek symbols -> DETECTED
+_filter.filter_text("привет") # Transliterated matches -> DETECTED
+
+```
+
+---
+
+## 🌍 Supported Languages
+
+`BadWords` currently supports **26 languages** out of the box:
+
+| Code | Language | Code | Language | Code | Language |
+| --- | --- | --- | --- | --- | --- |
+| `en` | English | `ru` | Russian | `ua` | Ukrainian |
+| `de` | German | `fr` | French | `it` | Italian |
+| `sp` | Spanish | `pl` | Polish | `cz` | Czech |
+| `ja` | Japanese | `ko` | Korean | `th` | Thai |
+| ... | & 14 more |  |  |  |  |
+
+*Use `p.get_all_languages()` to see the full list in your code.*
+
+---
+
+## 🚀 Full Integration Example
+
+```python
+from badwords import ProfanityFilter
+
+def monitor_chat():
+    # Setup for a global chat
+    profanity_filter = ProfanityFilter()
+    profanity_filter.init(["en", "ru", "de"])
+    
+    # Custom project-specific banned words
+    profanity_filter.add_words(["spam_link_v1", "scam_bot_99"])
+
+    user_input = "Hey! Check out this b.a.d.w.o.r.d"
+    
+    # Moderate with high accuracy
+    is_offensive = profanity_filter.filter_text(user_input, match_threshold=0.95)
+    
+    if is_offensive:
+        print("Message blocked: Contains restricted language.")
+    else:
+        # Proceed with processing
+        pass
+
+if __name__ == "__main__":
+    monitor_chat()
+
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions are what make the open-source community an amazing place to learn, inspire, and create.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+<div align="center">
+<sub>Developed with ❤️ by <a href="https://github.com/FlacSy">FlacSy</a></sub>
+</div>

badwords_py-2.1.0/README.md

@@ -0,0 +1,177 @@
+<div align="center">
+
+  # 🚫 BadWords
+
+  **High-performance profanity filter for Python with multilingual support and evasion detection.**
+
+  [![Python Version](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue?style=flat-square)](https://www.python.org/)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+  [![Build Status](https://img.shields.io/badge/build-passing-brightgreen?style=flat-square)](#)
+  [![Downloads](https://img.shields.io/pypi/dm/bad-words?style=flat-square&color=orange)](https://pypi.org/project/bad-words/)
+  
+  [Installation](#-installation) • [Quick Start](#-quick-start) • [Supported Languages](#-supported-languages) • [Advanced Evasion Detection](#-advanced-evasion-detection)
+
+</div>
+
+---
+
+## 📖 Description
+
+`BadWords` is a sophisticated profanity filtering library designed to clean up user-generated content. Unlike simple keyword matching, it uses **similarity scoring**, **homoglyph detection**, and **transliteration** to catch even the most cleverly disguised insults.
+
+## 📦 Installation
+
+### Requirements
+- **Recommended:** Python 3.13
+- **Minimum:** Python 3.10+
+
+### Install via GitHub
+```bash
+pip install git+[https://github.com/FlacSy/badwords.git](https://github.com/FlacSy/badwords.git)
+
+```
+
+### Install via PyPI
+```bash
+pip install badwords-py
+```
+
+---
+
+## ⚡ Quick Start
+
+### Basic Initialization
+
+```python
+from badwords import ProfanityFilter
+
+# Initialize filter
+p = ProfanityFilter()
+
+# Load specific languages (e.g., English and Russian)
+p.init(languages=["en", "ru"])
+
+# Or load ALL 26+ supported languages
+p.init()
+
+```
+
+### Checking and Filtering Text
+
+```python
+text = "Some very b4d text here"
+
+# 1. Simple check (Returns Boolean)
+is_bad = p.filter_text(text)
+print(is_bad) # True
+
+# 2. Censoring text (Returns String)
+clean_text = p.filter_text(text, replace_character="*")
+print(clean_text) # "Some very *** text here"
+
+```
+
+---
+
+## 🛠 Methods & API
+
+### `filter_text(text, match_threshold=0.8, replace_character=None)`
+
+The core method of the library.
+
+| Parameter | Type | Default | Description |
+| --- | --- | --- | --- |
+| `text` | `str` | Required | Input text to check. |
+| `match_threshold` | `float` | `0.8` | Similarity threshold (1.0 = exact match, 0.7 = aggressive). |
+| `replace_character` | `str/None` | `None` | If provided, returns censored string. If None, returns bool. |
+
+> [!WARNING]
+> **Performance Tip:** Using `match_threshold < 1.0` enables fuzzy matching which is slower. Use `1.0` for high-traffic real-time filtering, or `0.95` for a good balance.
+
+---
+
+## 🧩 Advanced Evasion Detection
+
+Standard filters are easy to bypass. `BadWords` is built to detect:
+
+* **Homoglyphs:** Detects `hеllo` (using Cyrillic 'е') or `h4llo` (numbers).
+* **Transliteration:** Automatically handles mapping between Cyrillic and Latin alphabets.
+* **Normalization:** Strips diacritics, special characters, and decorative Unicode symbols.
+* **Similarity Analysis:** Uses fuzzy matching to find words with deliberate typos.
+
+### Examples of detected evasions:
+
+```python
+_filter.filter_text("hеllо")  # Mixed alphabets (Cyrillic + Latin) -> DETECTED
+_filter.filter_text("h3ll0")  # Character substitution -> DETECTED
+_filter.filter_text("h⍺llo")  # Mathematical/Greek symbols -> DETECTED
+_filter.filter_text("привет") # Transliterated matches -> DETECTED
+
+```
+
+---
+
+## 🌍 Supported Languages
+
+`BadWords` currently supports **26 languages** out of the box:
+
+| Code | Language | Code | Language | Code | Language |
+| --- | --- | --- | --- | --- | --- |
+| `en` | English | `ru` | Russian | `ua` | Ukrainian |
+| `de` | German | `fr` | French | `it` | Italian |
+| `sp` | Spanish | `pl` | Polish | `cz` | Czech |
+| `ja` | Japanese | `ko` | Korean | `th` | Thai |
+| ... | & 14 more |  |  |  |  |
+
+*Use `p.get_all_languages()` to see the full list in your code.*
+
+---
+
+## 🚀 Full Integration Example
+
+```python
+from badwords import ProfanityFilter
+
+def monitor_chat():
+    # Setup for a global chat
+    profanity_filter = ProfanityFilter()
+    profanity_filter.init(["en", "ru", "de"])
+    
+    # Custom project-specific banned words
+    profanity_filter.add_words(["spam_link_v1", "scam_bot_99"])
+
+    user_input = "Hey! Check out this b.a.d.w.o.r.d"
+    
+    # Moderate with high accuracy
+    is_offensive = profanity_filter.filter_text(user_input, match_threshold=0.95)
+    
+    if is_offensive:
+        print("Message blocked: Contains restricted language.")
+    else:
+        # Proceed with processing
+        pass
+
+if __name__ == "__main__":
+    monitor_chat()
+
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions are what make the open-source community an amazing place to learn, inspire, and create.
+
+1. Fork the Project
+2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your Changes (`git commit -m 'Add AmazingFeature'`)
+4. Push to the Branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.
+
+<div align="center">
+<sub>Developed with ❤️ by <a href="https://github.com/FlacSy">FlacSy</a></sub>
+</div>

badwords_py-2.1.0/badwords/__init__.py

@@ -0,0 +1,5 @@
+"""A library for effective moderation of content."""
+
+from .check import ProfanityFilter
+
+__all__ = ["ProfanityFilter"]

badwords_py-2.1.0/badwords/check.py

@@ -0,0 +1,148 @@
+"""Module for checking text for badwords."""
+
+from __future__ import annotations
+
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .exceptions import NotSupportedLanguage
+from .text_processor import TextProcessor
+
+if TYPE_CHECKING:
+    from typing import Self
+else:
+    Self = "NotSupportedLanguage"
+
+
+class ProfanityFilter:
+    """A class for filtering profanity from text."""
+
+    def init(
+        self: Self,
+        languages: list[str] | None = None,
+        processing_normalize_text: bool = True,
+        processing_aggressive_normalize: bool = True,
+        processing_transliterate: bool = True,
+        processing_replace_homoglyphs: bool = True,
+    ) -> None:
+        """Initialize the profanity filter.
+
+        :param languages: List of languages to load profanity words for.
+        :param processing_normalize_text: Enable text normalization for all loaded words and word to filter
+        :param processing_aggressive_normalize: Enable aggressive text normalization for all loaded words and word to filter
+        :param processing_transliterate: Enable transliteration of text for all loaded words and word to filter
+        :param processing_replace_homoglyphs: Enable replacing of homoglyphs in the text for all loaded words and word to filter
+        """
+        self.resource_dir = Path(__file__).parent / "resource"
+
+        self.text_processor = TextProcessor(
+            processing_normalize_text=processing_normalize_text,
+            processing_aggressive_normalize=processing_aggressive_normalize,
+            processing_transliterate=processing_transliterate,
+            processing_replace_homoglyphs=processing_replace_homoglyphs
+        )
+
+        self.language_files = self.initialize_language_files()
+
+        if languages:
+            if all(i in self.language_files for i in languages):
+                self.language_files = languages
+            else:
+                raise NotSupportedLanguage
+
+        self.bad_words = self.initialize_bad_words()
+
+    def initialize_language_files(self: Self) -> list[str]:
+        """Initialize language files.
+
+        :return: Dictionary mapping language names to file paths.
+        """
+        return [str(path)[-6:-4] for path in (self.resource_dir).iterdir()]
+
+    def initialize_bad_words(self: Self) -> set[str]:
+        """Initialize the set of bad words from language files."""
+        bad_words: set[str] = set()
+        
+        for lang in self.language_files:
+            try:
+                # Sanitize the language code to prevent path traversal
+                lang = lang.lower().strip()
+                if not lang.isalpha():
+                    continue
+                    
+                file_path = self.resource_dir / f"{lang}.bdw"
+                if not file_path.exists():
+                    continue
+                    
+                with file_path.open(encoding="utf-8") as f:
+                    words = f.read().splitlines()
+                    processed_words = [self.text_processor.process_text(word) for word in words]
+                    bad_words.update(processed_words)
+            except Exception as e:
+                print(f"Error loading language file for {lang}: {e}")
+                continue
+                
+        return bad_words
+
+    def add_words(self: Self, words: list[str]) -> None:
+        """Add custom profanity words to the filter.
+
+        :param words: List of custom profanity words.
+        """
+        processed_words = [self.text_processor.process_text(word) for word in words]
+        self.bad_words.update(processed_words)
+
+    def similar(self: Self, a: str, b: str) -> float:
+        """Compute similarity ratio between two strings.
+
+        :param a: First string.
+        :param b: Second string.
+        :return: Similarity ratio.
+        """
+        return SequenceMatcher(None, a, b).ratio()
+
+    def filter_text(
+            self: Self, text: str,
+            match_threshold: float | None = None,
+            replace_character: str | None = None,
+        ) -> bool | str:
+        """Check if the given text contains profanity.
+
+        :param text: Input text to check.
+        :param match_threshold: Threshold for similarity match.
+        :param replace_character: Character to replace profane words with. If None,
+            return True/False.
+        :return: True if profanity found, False otherwise. If replace_character is
+            specified, return filtered text.
+        """
+        if not match_threshold:
+            match_threshold = 1
+
+        # Process the input text through all transformations
+        processed_text = self.text_processor.process_text(text)
+        words = processed_text.split()
+
+        for word in words:
+            # Check exact match
+            if word in self.bad_words:
+                if replace_character:
+                    return text.replace(word, replace_character * len(word))
+                return True
+
+            # Check similar matches if threshold is less than 1
+            if 0 < match_threshold < 1:
+                for bad_word in self.bad_words:
+                    if self.similar(word, bad_word) > match_threshold:
+                        if replace_character:
+                            return text.replace(word, replace_character * len(word))
+                        return True
+
+        return False
+
+    def get_all_languages(self: Self) -> list[str]:
+        """Get a list of all available languages.
+
+        :return: List of all language names.
+        """
+        return self.language_files

badwords_py-2.1.0/badwords/exceptions.py

@@ -0,0 +1,16 @@
+"""Exceptions module."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Self
+else:
+    Self = "NotSupportedLanguage"
+
+
+class NotSupportedLanguage(BaseException):
+    """Unsupport language check."""
+
+    def __str__(self: Self) -> str:
+        """String-like representation of exception."""
+        return "This language is not supported"

badwords_py-2.1.0/badwords/resource/br.bdw

@@ -0,0 +1,119 @@
+foderíamos
+fodêssemos
+foderíeis
+fodêramos
+fodêsseis
+merdimbuca
+putariinha
+chibundas
+chibundos
+cácété
+foderemos
+fodêreis
+fodíamos
+fudeção
+putariona
+boasudas
+boazudas
+cassetas
+chibunda
+chibundo
+culhões
+cunhões
+foderdes
+fodereis
+foderiam
+foderias
+fodermos
+foderás
+foderão
+fodessem
+fodesses
+fodestes
+fodíeis
+fudecão
+fudeçao
+fudidas?
+fudidos?
+peithola
+putarias
+xibundas
+xibundos
+babacas
+boasuda
+boazuda
+cacetas
+cacetes
+casseta
+cassete
+culhoes
+culhão
+cunhoes
+cunhão
+curalho
+fodamos
+fodasse
+fodemos
+fodendo
+foderam
+foderas
+foderei
+foderem
+foderes
+foderia
+foderum
+foderá
+fodesse
+fodeste
+fodinha
+fudecao
+fudedor
+fudendo
+furonas
+putaria
+putães
+putãos
+putões
+xibunda
+xibundo
+babaca
+bostas
+caceta
+cacete
+culhao
+cunhao
+fodais
+fodeis
+fodera
+fodete
+fodiam
+fodias
+fodão
+furona
+furão
+merdas
+putão
+sefoda
+bosta
+fodam
+fodao
+fodas
+fodei
+fodem
+foder
+fodes
+fodeu
+fodia
+fuder
+fudeu
+furao
+merda
+porra
+putos
+foda
+fode
+fodi
+fodo
+puto
+cus
+cu

badwords_py-2.1.0/badwords/resource/character_frequency.json

@@ -0,0 +1,12 @@
+{
+    "a": ["4", "@", "а"],
+    "b": ["8", "6", "в"],
+    "e": ["3", "ё", "е"],
+    "g": ["9", "6"],
+    "i": ["1", "!", "і"],
+    "l": ["1", "|", "!"],
+    "o": ["0", "о"],
+    "s": ["5", "$", "ѕ"],
+    "t": ["7", "+"],
+    "z": ["2", "z"]
+}