JavaScript ↔ Python Cross-Reference

interface ProfanityCheckResult {
  containsProfanity: boolean;
  profaneWords: string[];
  processedText?: string;
  filteredWords: string[];
  autoReplaced?: string;
  severityMap?: Record<string, SeverityLevel>;
  matches?: Match[];
  contextScore?: number;
}

interface ValidationResult {
  isValid: boolean;
  errors: string[];
  suggestions: string[];
  confidence: number;
  alternatives: Record<string, string[]>;
}

interface CacheStats {
  hits: number;
  misses: number;
  hitRate: number;
  size: number;
  maxSize: number;
}

class ProfanityCheckResult:
    contains_profanity: bool
    profane_words: List[str]
    processed_text: Optional[str]
    filtered_words: List[str]
    auto_replaced: Optional[str]
    severity_map: Optional[Dict[str, SeverityLevel]]
    matches: Optional[List[Match]]
    context_score: Optional[float]

class ValidationResult:
    is_valid: bool
    errors: List[str]
    suggestions: List[str]
    confidence: float
    alternatives: Dict[str, List[str]]

class CacheStats:
    hits: int
    misses: int
    hit_rate: float
    size: int
    max_size: int

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

// Basic usage
const result = checkProfanity("This is damn good!", {
  languages: ['english'],
  enableContextAware: true,
  confidenceThreshold: 0.7
});

// Filter class usage
const filter = new Filter({
  languages: ['english', 'spanish'],
  enableContextAware: true,
  autoReplace: true,
  replaceChar: '●'
});

const processedResult = filter.check("Text to analyze");

// Batch processing
const batchResults = filter.checkMultiple([
  "First text to check",
  "Second text to analyze",
  "Third piece of content"
]);

// Configuration updates
filter.updateConfig({
  confidenceThreshold: 0.8,
  severityFilter: 'MODERATE'
});

// Cache management
const stats = filter.getCacheStats();
filter.clearCache();

from glin_profanity import check_profanity, Filter

# Basic usage
result = check_profanity("This is damn good!", {
    'languages': ['english'],
    'enable_context_aware': True,
    'confidence_threshold': 0.7
})

# Filter class usage
filter_instance = Filter({
    'languages': ['english', 'spanish'],
    'enable_context_aware': True,
    'auto_replace': True,
    'replace_char': '●'
})

processed_result = filter_instance.check("Text to analyze")

# Batch processing
batch_results = filter_instance.check_multiple([
    "First text to check",
    "Second text to analyze", 
    "Third piece of content"
])

# Configuration updates
filter_instance.update_config({
    'confidence_threshold': 0.8,
    'severity_filter': 'MODERATE'
})

# Cache management
stats = filter_instance.get_cache_stats()
filter_instance.clear_cache()

import { checkProfanity, ProfanityError } from 'glin-profanity';

try {
  const result = checkProfanity(text, config);
  if (result.containsProfanity) {
    console.log('Profanity detected:', result.profaneWords);
  }
} catch (error) {
  if (error instanceof ProfanityError) {
    console.error('Profanity check failed:', error.message);
    console.error('Error code:', error.code);
  } else {
    console.error('Unexpected error:', error);
  }
}

// Async error handling
try {
  const result = await checkProfanityAsync(text, config);
} catch (error) {
  console.error('Async check failed:', error);
}

from glin_profanity import check_profanity, ProfanityError

try:
    result = check_profanity(text, config)
    if result['contains_profanity']:
        print('Profanity detected:', result['profane_words'])
except ProfanityError as e:
    print(f'Profanity check failed: {e.message}')
    print(f'Error code: {e.code}')
except Exception as e:
    print(f'Unexpected error: {e}')

# Async error handling
try:
    result = await check_profanity_async(text, config)
except Exception as e:
    print(f'Async check failed: {e}')