Severity Levels

export enum SeverityLevel {
  EXACT = 1,  // Direct dictionary matches
  FUZZY = 2,  // Fuzzy/obfuscated matches
}

from enum import IntEnum

class SeverityLevel(IntEnum):
    EXACT = 1  # Direct dictionary matches  
    FUZZY = 2  # Fuzzy/obfuscated matches

import { Filter, SeverityLevel } from 'glin-profanity';

const filter = new Filter({
  severityLevels: true,
  allowObfuscatedMatch: true
});

const text = "What the hell is this f*ck?";

// Only include FUZZY matches (obfuscated patterns)
const fuzzyOnly = filter.checkProfanityWithMinSeverity(text, SeverityLevel.FUZZY);
console.log(fuzzyOnly.filteredWords);  // ["f*ck"] - only obfuscated word
console.log(fuzzyOnly.result.severityMap);  // { "f*ck": 2 }

// Include all matches (EXACT + FUZZY)  
const allMatches = filter.checkProfanityWithMinSeverity(text, SeverityLevel.EXACT);
console.log(allMatches.filteredWords);  // ["hell", "f*ck"] - both words
console.log(allMatches.result.severityMap);  // { "hell": 1, "f*ck": 2 }

import { Filter, SeverityLevel } from 'glin-profanity';

// Content moderation with severity-based actions
class SeverityModerator {
  constructor() {
    this.filter = new Filter({
      severityLevels: true,
      allowObfuscatedMatch: true,
      enableContextAware: true,
      confidenceThreshold: 0.7
    });
  }

  moderateContent(text, userLevel = 'standard') {
    const policies = {
      strict: SeverityLevel.EXACT,    // Only flag direct profanity
      standard: SeverityLevel.FUZZY,  // Flag all profanity including obfuscated
      lenient: SeverityLevel.FUZZY    // Same as standard but with context analysis
    };

    const minSeverity = policies[userLevel] || SeverityLevel.FUZZY;
    const result = this.filter.checkProfanityWithMinSeverity(text, minSeverity);
    
    return {
      action: this.determineAction(result, userLevel),
      filteredWords: result.filteredWords,
      severityBreakdown: this.analyzeSeverity(result.result.severityMap),
      recommendation: this.getRecommendation(result, userLevel)
    };
  }

  analyzeSeverity(severityMap) {
    const breakdown = { exact: [], fuzzy: [] };
    
    for (const [word, severity] of Object.entries(severityMap || {})) {
      if (severity === SeverityLevel.EXACT) {
        breakdown.exact.push(word);
      } else if (severity === SeverityLevel.FUZZY) {
        breakdown.fuzzy.push(word);
      }
    }
    
    return breakdown;
  }

  determineAction(result, userLevel) {
    if (!result.result.containsProfanity) return 'approve';
    
    const { exact, fuzzy } = this.analyzeSeverity(result.result.severityMap);
    
    if (userLevel === 'strict' && exact.length > 0) return 'reject';
    if (userLevel === 'standard' && (exact.length > 0 || fuzzy.length > 2)) return 'flag';
    if (userLevel === 'lenient' && exact.length > 2) return 'warn';
    
    return 'approve';
  }
}

// Usage example
const moderator = new SeverityModerator();
const testCases = [
  'This movie is fucking brilliant!',    // Context-aware: likely positive
  'You damn sh1t f*cking idiot!',        // High severity: multiple FUZZY
  'What the hell is wrong?',             // Low severity: single EXACT
  'This d@mn thing is broken'            // Medium severity: single FUZZY
];

testCases.forEach(text => {
  const result = moderator.moderateContent(text, 'standard');
  console.log(`Text: "${text}"`);
  console.log(`Action: ${result.action}`);
  console.log(`EXACT: ${result.severityBreakdown.exact.join(', ')}`);
  console.log(`FUZZY: ${result.severityBreakdown.fuzzy.join(', ')}`);
  console.log('---');
});

from glin_profanity import Filter, SeverityLevel

filter_instance = Filter({
    "severity_levels": True,
    "allow_obfuscated_match": True
})

text = "What the hell is this f*ck?"

# Only include FUZZY matches (obfuscated patterns)
fuzzy_only = filter_instance.check_profanity_with_min_severity(text, SeverityLevel.FUZZY)
print(fuzzy_only["filtered_words"])     # ["f*ck"] - only obfuscated word
print(fuzzy_only["result"]["severity_map"])  # {"f*ck": 2}

# Include all matches (EXACT + FUZZY)
all_matches = filter_instance.check_profanity_with_min_severity(text, SeverityLevel.EXACT)  
print(all_matches["filtered_words"])    # ["hell", "f*ck"] - both words
print(all_matches["result"]["severity_map"])  # {"hell": 1, "f*ck": 2}

from glin_profanity import Filter, SeverityLevel

def test_severity_parity():
    """Verify identical behavior between JavaScript and Python implementations."""
    
    py_filter = Filter({
        "severity_levels": True,
        "allow_obfuscated_match": True,
        "fuzzy_tolerance_level": 0.8
    })
    
    # Test cases from cross-language parity tests
    test_cases = [
        "This damn text is very annoying",
        "What the hell is this word?",
        "Testing severity levels works"
    ]
    
    for text in test_cases:
        # Test complete results
        full_result = py_filter.check_profanity(text)
        print(f'Text: "{text}"')
        print(f'Full severity map: {full_result.get("severity_map", {})}')
        
        # Test EXACT+ filtering (includes EXACT and FUZZY)
        exact_plus = py_filter.check_profanity_with_min_severity(text, SeverityLevel.EXACT)
        print(f'EXACT+ filtered: {exact_plus["filtered_words"]}')
        
        # Test FUZZY-only filtering  
        fuzzy_only = py_filter.check_profanity_with_min_severity(text, SeverityLevel.FUZZY)
        print(f'FUZZY-only filtered: {fuzzy_only["filtered_words"]}')
        print('---')

test_severity_parity()