Zip Code Canada Python

// Zip Code Canada Python - JavaScript
const zipCodeCanadaPythonRegex = /^[a-zA-Z0-9._%+-]+$/;

function validateZipCodeCanadaPython(input) {
  if (typeof input !== 'string' || !input.trim()) {
    return { valid: false, error: 'Input must be a non-empty string' };
  }
  
  const isValid = zipCodeCanadaPythonRegex.test(input.trim());
  return {
    valid: isValid,
    value: input.trim(),
    pattern: '^[a-zA-Z0-9._%+-]+$'
  };
}

// Usage examples
console.log(validateZipCodeCanadaPython('valid-input'));
export { validateZipCodeCanadaPython };

# Zip Code Canada Python - Python
import re
from typing import Dict, Union

class ZipCodeCanadaPythonValidator:
    PATTERN = re.compile(r'^[a-zA-Z0-9._%+-]+$')
    
    @classmethod
    def validate(cls, input_data: str) -> Dict[str, Union[bool, str]]:
        if not isinstance(input_data, str) or not input_data.strip():
            return {
                'valid': False, 
                'error': 'Input must be a non-empty string'
            }
        
        cleaned_input = input_data.strip()
        is_valid = bool(cls.PATTERN.match(cleaned_input))
        
        return {
            'valid': is_valid,
            'value': cleaned_input,
            'pattern': '^[a-zA-Z0-9._%+-]+$'
        }

# Usage
validator = ZipCodeCanadaPythonValidator()
result = validator.validate('valid-input')

// Zip Code Canada Python - Java
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class ZipCodeCanadaPythonValidator {
    private static final Pattern PATTERN = Pattern.compile("^[a-zA-Z0-9._%+-]+$");
    
    public static class ValidationResult {
        public final boolean valid;
        public final String value;
        public final String error;
        
        public ValidationResult(boolean valid, String value, String error) {
            this.valid = valid;
            this.value = value;
            this.error = error;
        }
    }
    
    public static ValidationResult validate(String input) {
        if (input == null || input.trim().isEmpty()) {
            return new ValidationResult(false, null, "Input must be a non-empty string");
        }
        
        String trimmedInput = input.trim();
        Matcher matcher = PATTERN.matcher(trimmedInput);
        boolean isValid = matcher.matches();
        
        return new ValidationResult(isValid, trimmedInput, isValid ? null : "Pattern validation failed");
    }
}