String Methods & Text Sanitization

def parse_server_log(log_line: str) -> dict:
    entry = log_line.strip()
    
    # 1. Partition timestamp and remainder
    timestamp, sep, remainder = entry.partition(" [")
    if not sep:
        return {"valid": False, "raw": log_line}
        
    # 2. Partition log level
    level, sep2, remainder2 = remainder.partition("] ")
    if not sep2:
        return {"valid": False, "raw": log_line}
        
    # 3. Partition service and message
    service, sep3, message = remainder2.partition(": ")
    if not sep3:
        return {"valid": False, "raw": log_line}
        
    # 4. Extract optional latency suffix: '(latency=14ms)'
    latency_ms = None
    if message.endswith("ms)"):
        clean_msg, sep4, lat_chunk = message.rpartition("(latency=")
        if sep4:
            lat_digits = lat_chunk.removesuffix("ms)")
            if lat_digits.isdigit():
                latency_ms = int(lat_digits)
                message = clean_msg.strip()
                
    return {
        "valid": True,
        "timestamp": timestamp,
        "level": level.upper(),
        "service": service,
        "message": message,
        "latency_ms": latency_ms
    }

# Test with various server logs:
logs = [
    "2026-09-16 22:30:15 [INFO] auth_service: User 1042 authenticated successfully (latency=14ms)",
    "2026-09-16 22:30:18 [WARN] rate_limiter: IP 198.51.100.4 exceeded threshold",
    "Malformed entry without brackets"
]

print("=" * 65)
print(f"{'STRUCTURED SERVER LOG PARSER':^65}")
print("=" * 65)

for raw in logs:
    parsed = parse_server_log(raw)
    if parsed["valid"]:
        print(f"[{parsed['level']:<5}] Service: {parsed['service']:<14} | Latency: {str(parsed['latency_ms']) + 'ms':<6}")
        print(f"       Message: {parsed['message']}")
    else:
        print(f"[ERROR] Rejected malformed log entry: '{parsed['raw']}'")
    print("-" * 65)

import string

def sanitize_corpus_text(raw_text: str) -> list[str]:
    """
    Sanitizes raw text for search indexing using CPython-optimized translation tables.
    """
    # 1. Unicode casefold for international linguistic normalization
    folded = raw_text.casefold()
    
    # 2. Build high-speed translation table: delete all punctuation marks
    # str.maketrans(x, y, z): 3rd argument specifies characters to delete!
    delete_chars = string.punctuation
    trans_table = str.maketrans("", "", delete_chars)
    
    # 3. Translate in single C-level pass
    clean_text = folded.translate(trans_table)
    
    # 4. Split on arbitrary whitespace runs
    tokens = clean_text.split()
    return tokens

# Sample multilingual review with messy punctuation and German Eszett:
review = """
  PyLabs Cloud-DB (v2.4): It's FAST, reliable, & resilient!
  Cost: $0.00 / month. Über-große Speichergröße inklusive!
"""

print("=" * 60)
print(f"{'HIGH-SPEED NLP TEXT SANITIZER':^60}")
print("=" * 60)
print("Raw Input Document:")
print(review.strip())
print("-" * 60)

tokens = sanitize_corpus_text(review)
print(f"Extracted Clean Tokens ({len(tokens)} items):")
print(tokens)
print("=" * 60)

# Verify linguistic transformation
assert "fast" in tokens
assert "über-große" not in tokens  # Hyphen removed
assert "übergroße" in tokens
assert "speichergrösse" in tokens  # 'ß' folded to 'ss'!
print("Corpus Normalization & German Casefold Verified!")

def parse_ini_configuration(ini_text: str) -> dict[str, any]:
    config = {}
    
    for line in ini_text.splitlines():
        line = line.strip()
        # Skip blank lines and comments
        if not line or line.startswith(("#", ";")):
            continue
            
        key, sep, raw_val = line.partition("=")
        if not sep:
            continue  # Ignore lines without '='
            
        clean_key = key.strip()
        # Strip outer quotes: 'val' or "val"
        clean_val = raw_val.strip().strip(""'")
        
        # Type inference
        val_lower = clean_val.lower()
        if val_lower in ("true", "yes", "on"):
            typed_val = True
        elif val_lower in ("false", "no", "off"):
            typed_val = False
        elif clean_val.isdigit():
            typed_val = int(clean_val)
        else:
            typed_val = clean_val
            
        config[clean_key] = typed_val
        
    return config

def format_config_table(config: dict[str, any]) -> str:
    lines = []
    
    # Calculate column widths
    param_col_w = 24
    type_col_w = 12
    val_col_w = 26
    
    # Table header
    h_param = "PARAMETER".ljust(param_col_w)
    h_type = "TYPE".ljust(type_col_w)
    h_val = "VALUE".ljust(val_col_w)
    lines.append(f"| {h_param} | {h_type} | {h_val} |")
    
    # Divider
    d_param = "-" * param_col_w
    d_type = "-" * type_col_w
    d_val = "-" * val_col_w
    lines.append(f"|:{d_param}:|:{d_type}:|:{d_val}:|")
    
    # Rows sorted alphabetically by key
    for key in sorted(config.keys()):
        val = config[key]
        val_type = type(val).__name__
        
        r_param = key.ljust(param_col_w)
        r_type = val_type.ljust(type_col_w)
        r_val = str(val).ljust(val_col_w)
        lines.append(f"| {r_param} | {r_type} | {r_val} |")
        
    return "\n".join(lines)

# Sample production INI file
sample_ini = """
# PyLabs Cluster Configuration
CLUSTER_NAME = "pylabs-prod-eu"
NODE_COUNT = 16
AUTO_SCALE = true
MAX_WORKERS = 64
SSL_STRICT = on
TELEMETRY_ENDPOINT = "https://telemetry.pylabs.org/v1"
MAINTENANCE_MODE = false
"""

cfg = parse_ini_configuration(sample_ini)
report = format_config_table(cfg)
print(report)