glin-profanity 2.1.0__py3-none-any.whl

glin_profanity/__init__.py

@@ -0,0 +1,30 @@
+"""
+Glin-Profanity: A lightweight and efficient Python package for profanity detection.
+
+Provides multi-language support, context-aware filtering, and customizable
+configurations for detecting and filtering profane language in text inputs.
+"""
+
+__version__ = "2.1.0"
+__author__ = "glinr"
+__email__ = "contact@glincker.com"
+
+from .filters.filter import Filter
+from .types.types import (
+    CheckProfanityResult,
+    FilterConfig,
+    FilteredProfanityResult,
+    Language,
+    Match,
+    SeverityLevel,
+)
+
+__all__ = [
+    "CheckProfanityResult",
+    "Filter",
+    "FilterConfig",
+    "FilteredProfanityResult",
+    "Language",
+    "Match",
+    "SeverityLevel",
+]

glin_profanity/data/__init__.py

@@ -0,0 +1 @@
+"""Dictionary data loader for profanity detection."""

glin_profanity/data/dictionary.py

@@ -0,0 +1,89 @@
+"""Dictionary loader for profanity word lists."""
+
+import json
+from pathlib import Path
+
+from glin_profanity.types.types import Language
+
+
+class DictionaryLoader:
+    """Loads profanity dictionaries from shared JSON files."""
+
+    def __init__(self) -> None:
+        """Initialize dictionary loader."""
+        # Get path to shared dictionaries (relative to this file)
+        current_dir = Path(__file__).parent
+        self._dict_path = (
+            current_dir.parent.parent.parent.parent / "shared" / "dictionaries"
+        )
+        self._dictionaries: dict[str, list[str]] = {}
+        self._load_dictionaries()
+
+    def _raise_format_error(self, filename: str) -> None:
+        """Raise a ValueError for unexpected file format."""
+        msg = f"Unexpected format in {filename}"
+        raise ValueError(msg)
+
+    def _load_dictionaries(self) -> None:
+        """Load all dictionary files from shared directory."""
+        language_files = {
+            "arabic": "arabic.json",
+            "chinese": "chinese.json",
+            "czech": "czech.json",
+            "danish": "danish.json",
+            "english": "english.json",
+            "esperanto": "esperanto.json",
+            "finnish": "finnish.json",
+            "french": "french.json",
+            "german": "german.json",
+            "hindi": "hindi.json",
+            "hungarian": "hungarian.json",
+            "italian": "italian.json",
+            "japanese": "japanese.json",
+            "korean": "korean.json",
+            "norwegian": "Norwegian.json",
+            "persian": "persian.json",
+            "polish": "polish.json",
+            "portuguese": "portuguese.json",
+            "russian": "russian.json",
+            "spanish": "spanish.json",
+            "swedish": "swedish.json",
+            "thai": "thai.json",
+            "turkish": "turkish.json",
+        }
+
+        for language, filename in language_files.items():
+            file_path = self._dict_path / filename
+            try:
+                with file_path.open(encoding="utf-8") as f:
+                    data = json.load(f)
+                    # Handle both {"words": [...]} and [...] formats
+                    if isinstance(data, dict) and "words" in data:
+                        self._dictionaries[language] = data["words"]
+                    elif isinstance(data, list):
+                        self._dictionaries[language] = data
+                    else:
+                        self._raise_format_error(filename)
+            except (FileNotFoundError, json.JSONDecodeError, ValueError) as e:
+                print(f"Warning: Could not load {filename}: {e}")  # noqa: T201
+                self._dictionaries[language] = []
+
+    def get_words(self, language: Language) -> list[str]:
+        """Get words for a specific language."""
+        return self._dictionaries.get(language, [])
+
+    def get_all_words(self) -> list[str]:
+        """Get all words from all languages."""
+        all_words = []
+        for words in self._dictionaries.values():
+            all_words.extend(words)
+        return list(set(all_words))  # Remove duplicates
+
+    @property
+    def available_languages(self) -> list[str]:
+        """Get list of available languages."""
+        return list(self._dictionaries.keys())
+
+
+# Global instance
+dictionary = DictionaryLoader()

glin_profanity/filters/__init__.py

@@ -0,0 +1,5 @@
+"""Profanity filtering components."""
+
+from .filter import Filter
+
+__all__ = ["Filter"]

glin_profanity/filters/filter.py

@@ -0,0 +1,314 @@
+"""Main Filter class for profanity detection and filtering."""
+
+import re
+
+from glin_profanity.data.dictionary import dictionary
+from glin_profanity.types.types import (
+    CheckProfanityResult,
+    FilterConfig,
+    Match,
+    SeverityLevel,
+)
+
+
+class Filter:
+    """
+    Main profanity filter class.
+
+    Provides functionality to detect and filter profane language in text
+    with support for multiple languages, custom configurations, and
+    context-aware filtering.
+    """
+
+    def __init__(self, config: FilterConfig | None = None) -> None:
+        """
+        Initialize the profanity filter.
+
+        Args:
+            config: Configuration options for the filter
+        """
+        config = config or {}
+
+        # Basic configuration
+        self.case_sensitive = config.get("case_sensitive", False)
+        self.allow_obfuscated_match = config.get("allow_obfuscated_match", False)
+        self.word_boundaries = config.get(
+            "word_boundaries", not self.allow_obfuscated_match
+        )
+        self.replace_with = config.get("replace_with")
+        self.severity_levels = config.get("severity_levels", False)
+        self.log_profanity = config.get("log_profanity", False)
+        self.fuzzy_tolerance_level = config.get("fuzzy_tolerance_level", 0.8)
+
+        # Context-aware configuration
+        self.enable_context_aware = config.get("enable_context_aware", False)
+        self.context_window = config.get("context_window", 3)
+        self.confidence_threshold = config.get("confidence_threshold", 0.7)
+
+        # Initialize word sets
+        ignore_words_list = config.get("ignore_words", [])
+        self.ignore_words: set[str] = {word.lower() for word in ignore_words_list}
+
+        # Load dictionary words
+        self._load_words(config)
+
+    def _load_words(self, config: FilterConfig) -> None:
+        """Load profanity words based on configuration."""
+        words: list[str] = []
+
+        if config.get("all_languages", False):
+            words = dictionary.get_all_words()
+        else:
+            languages = config.get("languages", ["english"])
+            if languages:
+                for lang in languages:
+                    words.extend(dictionary.get_words(lang))
+
+        # Add custom words if provided
+        custom_words = config.get("custom_words")
+        if custom_words:
+            words.extend(custom_words)
+
+        # Store as set for faster lookup
+        self.words: set[str] = {word.lower() for word in words}
+
+    def _debug_log(self, *args: object) -> None:
+        """Log debug information if logging is enabled."""
+        if self.log_profanity:
+            print("[glin-profanity]", *args)  # noqa: T201
+
+    def _normalize_obfuscated(self, text: str) -> str:
+        """Normalize obfuscated text by replacing common character substitutions."""
+        # Remove repeated characters (e.g., "hiiiii" -> "hii")
+        normalized = re.sub(r"([a-zA-Z])\1{1,}", r"\1\1", text)
+
+        # Character substitution map
+        char_map = {
+            "@": "a",
+            "$": "s",
+            "!": "i",
+            "1": "i",
+            "*": "",
+        }
+
+        for char, replacement in char_map.items():
+            normalized = normalized.replace(char, replacement)
+
+        return normalized
+
+    def _get_regex(self, word: str) -> re.Pattern[str]:
+        """Create regex pattern for word matching."""
+        flags = 0 if self.case_sensitive else re.IGNORECASE
+        escaped_word = re.escape(word)
+
+        pattern = rf"\b{escaped_word}\b" if self.word_boundaries else escaped_word
+
+        return re.compile(pattern, flags)
+
+    def _is_fuzzy_tolerance_match(self, word: str, text: str) -> bool:
+        """Check if word matches text within fuzzy tolerance."""
+        simplified_text = re.sub(r"[^a-z]", "", text.lower())
+        simplified_word = word.lower()
+
+        # If word boundaries are enabled, don't do fuzzy matching
+        # that could match across word boundaries
+        if self.word_boundaries:
+            # Only do fuzzy matching if the word appears as a separate token
+            words_in_text = re.findall(r"\b\w+\b", text.lower())
+            for text_word in words_in_text:
+                if self._fuzzy_match_single_word(simplified_word, text_word):
+                    return True
+            return False
+
+        # Original fuzzy matching for non-word-boundary mode
+        match_count = 0
+        index = 0
+
+        for char in simplified_text:
+            if index < len(simplified_word) and char == simplified_word[index]:
+                match_count += 1
+                index += 1
+
+        score = match_count / len(simplified_word) if simplified_word else 0
+        return score >= self.fuzzy_tolerance_level
+
+    def _fuzzy_match_single_word(self, pattern_word: str, text_word: str) -> bool:
+        """Check if a single word matches the pattern with fuzzy tolerance."""
+        # For word boundary mode, require a more exact match
+        # The pattern word should be roughly the same length as the text word
+        if abs(len(pattern_word) - len(text_word)) > max(1, len(pattern_word) // 2):
+            return False
+
+        match_count = 0
+        index = 0
+
+        for char in text_word:
+            if index < len(pattern_word) and char == pattern_word[index]:
+                match_count += 1
+                index += 1
+
+        score = match_count / len(pattern_word) if pattern_word else 0
+        return score >= self.fuzzy_tolerance_level
+
+    def _evaluate_severity(self, word: str, text: str) -> SeverityLevel | None:
+        """Evaluate the severity level of a match."""
+        regex = self._get_regex(word)
+
+        if regex.search(text):
+            return SeverityLevel.EXACT
+        if self._is_fuzzy_tolerance_match(word, text):
+            return SeverityLevel.FUZZY
+
+        return None
+
+    def is_profane(self, value: str) -> bool:
+        """
+        Check if text contains profanity.
+
+        Args:
+            value: Text to check
+
+        Returns:
+            True if profanity is detected, False otherwise
+        """
+        input_text = (
+            self._normalize_obfuscated(value) if self.allow_obfuscated_match else value
+        )
+
+        for word in self.words:
+            if (
+                word.lower() not in self.ignore_words
+                and self._evaluate_severity(word, input_text) is not None
+            ):
+                return True
+
+        return False
+
+    def matches(self, word: str) -> bool:
+        """
+        Check if a single word matches profanity patterns.
+
+        Args:
+            word: Word to check
+
+        Returns:
+            True if word matches profanity, False otherwise
+        """
+        return self.is_profane(word)
+
+    def check_profanity(self, text: str) -> CheckProfanityResult:
+        """
+        Comprehensive profanity check with detailed results.
+
+        Args:
+            text: Text to analyze
+
+        Returns:
+            Detailed results of profanity analysis
+        """
+        input_text = (
+            self._normalize_obfuscated(text) if self.allow_obfuscated_match else text
+        )
+        input_lower = input_text.lower()
+
+        profane_words: list[str] = []
+        severity_map: dict[str, SeverityLevel] = {}
+        matches: list[Match] = []
+
+        # Check each word in dictionary
+        for dict_word in self.words:
+            if dict_word.lower() in self.ignore_words:
+                continue
+
+            severity = self._evaluate_severity(dict_word, input_text)
+            if severity is not None:
+                regex = self._get_regex(dict_word)
+
+                # Find all matches
+                for match in regex.finditer(input_text):
+                    matched_word = match.group(0)
+                    match_index = match.start()
+
+                    profane_words.append(matched_word)
+                    severity_map[matched_word] = severity
+
+                    # Create match object
+                    match_obj: Match = {
+                        "word": matched_word,
+                        "index": match_index,
+                        "severity": severity,
+                    }
+
+                    # TODO: Add context analysis when implemented
+                    matches.append(match_obj)
+
+        # Log detected profanity
+        if profane_words:
+            self._debug_log("Detected:", profane_words)
+
+        # Process text replacement if configured
+        processed_text = text
+        if self.replace_with and profane_words:
+            unique_words = list(set(profane_words))
+            for word in unique_words:
+                escaped = re.escape(word)
+                if self.word_boundaries:
+                    replacement_regex = re.compile(rf"\b{escaped}\b", re.IGNORECASE)
+                else:
+                    replacement_regex = re.compile(escaped, re.IGNORECASE)
+                processed_text = replacement_regex.sub(
+                    self.replace_with, processed_text
+                )
+
+        # Build result
+        result: CheckProfanityResult = {
+            "contains_profanity": len(profane_words) > 0,
+            "profane_words": list(set(profane_words)),
+        }
+
+        if self.replace_with:
+            result["processed_text"] = processed_text
+
+        if self.severity_levels and severity_map:
+            result["severity_map"] = severity_map
+
+        if matches:
+            result["matches"] = matches
+
+        result["reason"] = (
+            f"Found {len(matches)} potential profanity matches"
+            if matches
+            else "No profanity detected"
+        )
+
+        return result
+
+    def check_profanity_with_min_severity(
+        self, text: str, min_severity: SeverityLevel = SeverityLevel.EXACT
+    ) -> dict[str, object]:
+        """
+        Check profanity with minimum severity filtering.
+
+        Args:
+            text: Text to analyze
+            min_severity: Minimum severity level to include
+
+        Returns:
+            Dictionary with filtered words and full result
+        """
+        result = self.check_profanity(text)
+
+        filtered_words = []
+        severity_map = result.get("severity_map")
+        profane_words = result.get("profane_words")
+        if severity_map and profane_words:
+            filtered_words = [
+                word
+                for word in profane_words
+                if severity_map.get(word, 0) >= min_severity
+            ]
+
+        return {
+            "filtered_words": filtered_words,
+            "result": result,
+        }

glin_profanity/nlp/__init__.py

@@ -0,0 +1 @@
+"""NLP components for glin-profanity."""

glin_profanity/types/__init__.py

@@ -0,0 +1,21 @@
+"""Type definitions for glin-profanity."""
+
+from .types import (
+    CheckProfanityResult,
+    ContextAwareConfig,
+    FilterConfig,
+    FilteredProfanityResult,
+    Language,
+    Match,
+    SeverityLevel,
+)
+
+__all__ = [
+    "CheckProfanityResult",
+    "ContextAwareConfig",
+    "FilterConfig",
+    "FilteredProfanityResult",
+    "Language",
+    "Match",
+    "SeverityLevel",
+]

glin_profanity/types/types.py

@@ -0,0 +1,96 @@
+"""
+Type definitions for glin-profanity Python package.
+Unified API that mirrors the JavaScript/TypeScript package structure.
+"""
+
+from enum import IntEnum
+from typing import Literal, TypedDict
+
+# Supported languages - unified list with JavaScript
+Language = Literal[
+    "arabic",
+    "chinese",
+    "czech",
+    "danish",
+    "english",
+    "esperanto",
+    "finnish",
+    "french",
+    "german",
+    "hindi",
+    "hungarian",
+    "italian",
+    "japanese",
+    "korean",
+    "norwegian",
+    "persian",
+    "polish",
+    "portuguese",
+    "russian",
+    "spanish",
+    "swedish",
+    "thai",
+    "turkish",
+]
+
+
+class SeverityLevel(IntEnum):
+    """Severity levels for profanity matches - unified with JavaScript."""
+
+    EXACT = 1
+    FUZZY = 2
+
+
+class Match(TypedDict, total=False):
+    """Represents a profanity match in text - unified with JavaScript."""
+
+    word: str
+    index: int
+    severity: SeverityLevel
+    context_score: float | None
+    reason: str | None
+    is_whitelisted: bool | None
+
+
+class CheckProfanityResult(TypedDict, total=False):
+    """Result of profanity check operation - unified field names."""
+
+    contains_profanity: bool
+    profane_words: list[str]
+    processed_text: str | None
+    severity_map: dict[str, SeverityLevel] | None
+    matches: list[Match] | None
+    context_score: float | None
+    reason: str | None
+
+
+class ContextAwareConfig(TypedDict, total=False):
+    """Configuration for context-aware filtering - unified with JavaScript."""
+
+    enable_context_aware: bool
+    context_window: int
+    confidence_threshold: float
+    domain_whitelists: dict[str, list[str]] | None
+
+
+class FilterConfig(ContextAwareConfig, total=False):
+    """Main filter configuration options - unified with JavaScript."""
+
+    languages: list[Language] | None
+    all_languages: bool
+    case_sensitive: bool
+    word_boundaries: bool
+    custom_words: list[str] | None
+    replace_with: str | None
+    severity_levels: bool
+    ignore_words: list[str] | None
+    log_profanity: bool
+    allow_obfuscated_match: bool
+    fuzzy_tolerance_level: float
+
+
+class FilteredProfanityResult(TypedDict):
+    """Result with minimum severity filtering."""
+
+    result: CheckProfanityResult
+    filtered_words: list[str]

glin_profanity-2.1.0.dist-info/METADATA

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: glin-profanity
+Version: 2.1.0
+Summary: Glin-Profanity is a lightweight and efficient Python package designed to detect and filter profane language in text inputs across multiple languages.
+Project-URL: Homepage, https://www.glincker.com/tools/glin-profanity
+Project-URL: Documentation, https://github.com/GLINCKER/glin-profanity
+Project-URL: Repository, https://github.com/GLINCKER/glin-profanity
+Project-URL: Issues, https://github.com/GLINCKER/glin-profanity/issues
+Author-email: glinr <contact@glincker.com>
+Maintainer-email: glinr <contact@glincker.com>
+License-Expression: MIT
+Keywords: censorship,chat,comment,content,detection,filter,glin,glincker,language,moderation,nlp,profanity,social,text
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Filters
+Requires-Python: >=3.10
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: isort>=5.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4.0.0; extra == 'test'
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Glin-Profanity Python Package
+
+A lightweight and efficient Python package designed to detect and filter profane language in text inputs across multiple languages.
+
+## Features
+
+- 🌍 **Multi-language Support**: Supports 25+ languages including English, Spanish, French, German, Arabic, Chinese, and many more
+- 🎯 **Context-Aware Filtering**: Advanced context analysis to reduce false positives
+- ⚙️ **Highly Configurable**: Customize word lists, severity levels, and filtering behavior
+- 🚀 **High Performance**: Optimized for speed and efficiency
+- 🔧 **Easy Integration**: Simple API that works with any Python application
+- 📝 **TypeScript Compatible**: Mirrors the API of the TypeScript version
+
+## Installation
+
+```bash
+pip install glin-profanity
+```
+
+## Quick Start
+
+```python
+from glin_profanity import Filter
+
+# Basic usage
+filter_instance = Filter()
+
+# Check if text contains profanity
+if filter_instance.is_profane("This is a damn example"):
+    print("Profanity detected!")
+
+# Get detailed results
+result = filter_instance.check_profanity("This is a damn example")
+print(result["profane_words"])  # ['damn']
+print(result["contains_profanity"])  # True
+```
+
+## Configuration Options
+
+```python
+from glin_profanity import Filter, SeverityLevel
+
+# Advanced configuration
+config = {
+    "languages": ["english", "spanish"],  # Specific languages
+    "case_sensitive": False,              # Case sensitivity
+    "word_boundaries": True,              # Enforce word boundaries
+    "replace_with": "***",                # Replacement text
+    "severity_levels": True,              # Enable severity detection
+    "custom_words": ["badword"],          # Add custom words
+    "ignore_words": ["exception"],        # Ignore specific words
+    "allow_obfuscated_match": True,       # Detect obfuscated text
+    "fuzzy_tolerance_level": 0.8,         # Fuzzy matching threshold
+}
+
+filter_instance = Filter(config)
+```
+
+## API Reference
+
+### Filter Class
+
+#### `__init__(config: Optional[FilterConfig] = None)`
+Initialize the filter with optional configuration.
+
+#### `is_profane(text: str) -> bool`
+Check if text contains profanity. Returns `True` if profanity is detected.
+
+#### `check_profanity(text: str) -> CheckProfanityResult`
+Perform comprehensive profanity analysis with detailed results.
+
+#### `matches(word: str) -> bool`
+Check if a single word matches profanity patterns. Alias for `is_profane()`.
+
+#### `check_profanity_with_min_severity(text: str, min_severity: SeverityLevel) -> Dict`
+Check profanity with minimum severity filtering.
+
+### Types
+
+#### `CheckProfanityResult`
+```python
+{
+    "contains_profanity": bool,
+    "profane_words": List[str],
+    "processed_text": Optional[str],      # If replace_with is set
+    "severity_map": Optional[Dict],       # If severity_levels is True
+    "matches": Optional[List[Match]],     # Detailed match information
+    "context_score": Optional[float],     # Context analysis score
+    "reason": Optional[str]               # Analysis reason
+}
+```
+
+#### `SeverityLevel`
+- `SeverityLevel.EXACT`: Exact word match
+- `SeverityLevel.FUZZY`: Fuzzy/approximate match
+
+## Supported Languages
+
+Arabic, Chinese, Czech, Danish, English, Esperanto, Finnish, French, German, Hindi, Hungarian, Italian, Japanese, Korean, Norwegian, Persian, Polish, Portuguese, Russian, Spanish, Swedish, Thai, Turkish
+
+## Development
+
+### Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/GLINCKER/glin-profanity
+cd glin-profanity/packages/py
+
+# Install with development dependencies
+pip install -e ".[dev]"
+```
+
+### Testing
+
+```bash
+# Run tests
+pytest
+
+# Run tests with coverage
+pytest --cov=glin_profanity
+```
+
+### Code Quality
+
+```bash
+# Format code
+black glin_profanity tests
+
+# Sort imports
+isort glin_profanity tests
+
+# Type checking
+mypy glin_profanity
+
+# Linting
+ruff check glin_profanity tests
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](../../LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please read our [Contributing Guide](../../CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## Support
+
+- 📖 [Documentation](https://github.com/GLINCKER/glin-profanity)
+- 🐛 [Issue Tracker](https://github.com/GLINCKER/glin-profanity/issues)
+- 💬 [Discussions](https://github.com/GLINCKER/glin-profanity/discussions)
+
+## Changelog
+
+See [CHANGELOG.md](../../CHANGELOG.md) for a list of changes and updates.

glin_profanity-2.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+glin_profanity/__init__.py,sha256=57skWl1ZcA1J_3U0fzRObWB1pECGkweq5OIBXaY3vQc,663
+glin_profanity/data/__init__.py,sha256=NcAqOA-dbui3i4mzQq3t0c0j3Tb-gtQyq-Fw0yMaQLo,54
+glin_profanity/data/dictionary.py,sha256=3g6cDTek8GU5OuUdjAENE7QrBRS6lMJ6AjdtVF9Uego,3313
+glin_profanity/filters/__init__.py,sha256=vE66zFbyd44Tmaz0MrqlAm-l3NpMeQE51tcCoZ6Z5go,88
+glin_profanity/filters/filter.py,sha256=IytUJblOLnpVclDJFxh71RgrqcZf-6cdKyHX2MWMWgQ,10505
+glin_profanity/nlp/__init__.py,sha256=rUIC7qVYUvuTi9kta2rI3mPuSZuQRN88jnOeCEjE_7s,41
+glin_profanity/types/__init__.py,sha256=1bPXoDfhmLQWSLIjj4eztbcySpM6N3U-ydvnzOYYoyw,378
+glin_profanity/types/types.py,sha256=JcCkCAgxsB9RHRGWrbRw8snHRq92rxaLvY7aRsOHXP4,2238
+glin_profanity-2.1.0.dist-info/METADATA,sha256=JkgHpre050ymS-JIzZaJkdzNS49-AxAoAHOvvGkT7pA,6306
+glin_profanity-2.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+glin_profanity-2.1.0.dist-info/RECORD,,

glin_profanity-2.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any