Strings & Text Representation

def sanitize_and_validate_email(raw_input: str) -> tuple[bool, str, str, str]:
    # 1. Clean whitespace and normalize case
    clean_email = raw_input.strip().lower()
    
    print("=" * 48)
    print(f"{'USER REGISTRATION EMAIL SANITIZER':^48}")
    print("=" * 48)
    print(f"Raw Input:      '{raw_input}'")
    print(f"Sanitized:      '{clean_email}'")
    
    # 2. Structural validation checks
    has_valid_at = clean_email.count("@") == 1
    has_valid_tld = clean_email.endswith((".com", ".org", ".net"))
    
    if not (has_valid_at and has_valid_tld):
        print("Validation:     REJECTED (Malformed format or invalid TLD)")
        print("=" * 48)
        return False, clean_email, "", ""
        
    # 3. Extract username and domain
    username, domain = clean_email.split("@")
    print(f"Username:       {username}")
    print(f"Domain:         {domain}")
    print("Validation:     ACCEPTED")
    print("=" * 48)
    return True, clean_email, username, domain

# Test 1: Messy input with uppercase and trailing newlines
is_valid, email, user, dom = sanitize_and_validate_email("   Learner.Dev@PyLabs.ORG   \n")

# Test 2: Invalid email with multiple @ symbols
is_valid2, email2, _, _ = sanitize_and_validate_email("bad@@domain.com")

def transform_csv_to_markdown_table(csv_lines: list[str]) -> str:
    output_rows = []
    
    # Table headers
    header = "| ID    | Name         | Department   | Salary   |"
    divider = "|:------|:-------------|:-------------|:---------|"
    output_rows.append(header)
    output_rows.append(divider)
    
    for line in csv_lines:
        # Skip empty lines or comments
        if not line.strip() or line.strip().startswith("#"):
            continue
            
        # 1. Split columns by delimiter
        raw_cols = line.split(",")
        
        # 2. Clean each column with strip()
        clean_cols = [c.strip() for c in raw_cols]
        
        if len(clean_cols) != 4:
            continue  # Skip corrupt row
            
        emp_id, name, dept, salary = clean_cols
        
        # 3. Transform casing
        dept_formatted = dept.upper()
        
        # 4. Format aligned row
        formatted_row = f"| {emp_id:<5} | {name:<12} | {dept_formatted:<12} | {salary:<8} |"
        output_rows.append(formatted_row)
        
    # 5. Assemble table with join() in O(N) time
    return "\n".join(output_rows)

raw_data = [
    "# Employee Compensation Ledger",
    "  101 , Alice Smith , Engineering , $125000  ",
    "  102 , Bob Jones   , Marketing   , $95000   ",
    "  ",  # Empty row to filter
    "  103 , Carol White , Engineering , $110000  "
]

markdown_table = transform_csv_to_markdown_table(raw_data)
print(markdown_table)

def canonicalize_url_endpoint(raw_url: str) -> str:
    """
    Normalizes a URL query string by alphabetizing parameters and escaping spaces,
    guaranteeing uniform cache keys for API proxy caches.
    """
    # 1. Separate path from query string
    if "?" not in raw_url:
        return raw_url.strip()
        
    base_path, raw_query = raw_url.split("?", 1)
    base_path = base_path.strip()
    
    # 2. Parse key-value query parameters
    param_dict = {}
    query_tokens = raw_query.split("&")
    
    for token in query_tokens:
        if not token:
            continue
        if "=" in token:
            key, val = token.split("=", 1)
            # Unescape '+' as spaces and normalize whitespace
            clean_key = key.strip()
            clean_val = val.replace("+", " ").strip()
            param_dict[clean_key] = clean_val
        else:
            # Handle boolean flags without values
            param_dict[token.strip()] = ""
            
    # 3. Sort keys alphabetically for canonical ordering
    sorted_keys = sorted(param_dict.keys())
    
    # 4. Reassemble canonical parameter pairs
    reconstructed_pairs = []
    for k in sorted_keys:
        v = param_dict[k]
        escaped_v = v.replace(" ", "+")
        if escaped_v:
            reconstructed_pairs.append(f"{k}={escaped_v}")
        else:
            reconstructed_pairs.append(k)
            
    canonical_query = "&".join(reconstructed_pairs)
    return f"{base_path}?{canonical_query}"

# Simulated diverse requests that should hit the same cache key:
client_urls = [
    "/api/v1/search?sort=desc&query=python+lists&limit=25&page=1",
    "/api/v1/search?page=1&query=python+lists&sort=desc&limit=25",
    "/api/v1/search?limit=25&sort=desc&page=1&query=python+lists"
]

print("=" * 70)
print(f"{'CANONICAL URL REVERSE PROXY CACHE NORMALIZER':^70}")
print("=" * 70)

for i, url in enumerate(client_urls, 1):
    normalized = canonicalize_url_endpoint(url)
    print(f"Client #{i} Raw:        {url}")
    print(f"Client #{i} Canonical:  {normalized}")
    print("-" * 70)
    
# Verify cache convergence
assert len({canonicalize_url_endpoint(u) for u in client_urls}) == 1
print("Cache Convergence Verified: All client variants resolve to 1 identical key!")
print("=" * 70)