Unit 4: Strings & Text Processing

import sys

# 1. Standard single & double quote equivalence
title_a = 'Python Engineering'
title_b = "Python Engineering"
print(title_a == title_b)             # True

# 2. Raw string prevents escape character processing
normal_path = "C:\\Users\\shivan"      # Requires manual backslash escaping
raw_path    = r"C:\Users\shivan"      # Pure raw literal, backslashes preserved intact
print(normal_path == raw_path)        # True

# 3. Memory footprint: sys.getsizeof shows PEP 393 adaptive sizing
ascii_str = "hello"                   # 1 byte per character
emoji_str = "hello🚀"                 # 4 bytes per character allocated for entire string!
print(f"ASCII size: {sys.getsizeof(ascii_str)}B | Emoji size: {sys.getsizeof(emoji_str)}B")

word = "DEVASCENT"

# 1. Single character extraction
print(word[0])           # 'D' (First character)
print(word[-1])          # 'T' (Last character)

# 2. Basic slicing [start:stop] -> extracts indices 3, 4, 5
print(word[3:6])         # 'ASC' (Stops before index 6!)

# 3. Default boundaries: omittted start defaults to 0; omitted stop defaults to end
print(word[:3])          # 'DEV' (Prefix: index 0 up to 2)
print(word[3:])          # 'ASCENT' (Suffix: index 3 to end)

# 4. Step Stride [start:stop:step]
print(word[::2])         # 'DVSET' (Every 2nd character)

# 5. Idiomatic String Inversion via negative step
print(word[::-1])        # 'TNECSAVED' (Reverses the entire string)

# 1. Plus (+) Operator Concatenation
first = "DevAscent"
last = "Academy"
full = first + " " + last
print(full)                     # 'DevAscent Academy'

# 2. Multiplication (*) Repetition Operator
divider = "=" * 30
print(divider)                  # '=============================='

# 3. Implicit Literal Concatenation (Compiler Optimization)
sql_query = (
    "SELECT user_id, email, status "
    "FROM production_users "
    "WHERE is_active = True;"
)
print(sql_query)

# The High-Performance str.join() Architecture:
tokens = ["order_id_101", "user_99", "amount_450", "status_PAID"]

# Separator string invokes join() on the collection
csv_line = ",".join(tokens)
print(f"CSV Row: {csv_line}")

path_str = "/".join(["api", "v2", "telemetry", "status"])
print(f"URI:     {path_str}")

# 1. Delimiter conflict resolution
dialogue = "The student exclaimed: \"DevAscent's curriculum is unmatched!\""
print(dialogue)

# 2. Raw Strings (r"") suppress all backslash interpretation
regex_pattern = r"^[a-zA-Z0-9_\-\.]+@[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-\.]+$"
windows_dir   = r"C:\Users\administrator\new_datasets"
print(f"Regex Pattern: {regex_pattern}")
print(f"Windows Dir:   {windows_dir}")

# 3. Unicode code point synthesis
symbol_omega = "\u03A9"
rocket_badge = "\U0001F680"
print(f"Architecture Node: {symbol_omega} | Status: Launch {rocket_badge}")

raw_input = "dEvAsCeNt aCaDeMy"

print(raw_input.upper())      # 'DEVASCENT ACADEMY'
print(raw_input.lower())      # 'devascent academy'
print(raw_input.title())      # 'Devascent Academy'
print(raw_input.capitalize()) # 'Devascent academy' (Only 1st char capital)

# German sharp 's' (ß) casefold converts to 'ss' for Unicode case-insensitive matching
german_word = "Straße"
print(german_word.lower() == "strasse")     # False! lower() produces 'straße'
print(german_word.casefold() == "strasse")  # True! casefold() performs aggressive Unicode folding

user_entry = "   \n\t student_raja@devascent.me \t\n   "
clean_entry = user_entry.strip()
print(f"Cleaned: '{clean_entry}'")   # 'student_raja@devascent.me'

# The Classic rstrip/lstrip character-set trap:
url = "https://devascentacademy.me/python"
print(url.lstrip("https://"))         # 'devascentacademy.me/python' (Seems fine...)
buggy = "http://pothole.com"
print(buggy.lstrip("http://"))       # 'ole.com'! (Stripped 'p', 'o', 't', 'h' as set!)

# The Python 3.9+ Safe Solution: removeprefix() and removesuffix()
print(buggy.removeprefix("http://"))  # 'pothole.com' (Safe exact substring removal!)
file_name = "report_archive.tar.gz"
print(file_name.removesuffix(".gz"))  # 'report_archive.tar'

config_template = "HOST=127.0.0.1; PORT=8000; HOST=127.0.0.1"

# Replaces ALL occurrences
updated_all = config_template.replace("127.0.0.1", "0.0.0.0")
print(updated_all)  # 'HOST=0.0.0.0; PORT=8000; HOST=0.0.0.0'

# Replaces only first occurrence via optional count argument
updated_first = config_template.replace("127.0.0.1", "0.0.0.0", 1)
print(updated_first) # 'HOST=0.0.0.0; PORT=8000; HOST=127.0.0.1'

# Default split() collapses arbitrary consecutive whitespace
messy_row = "DevAscent   Cohort    14     Active"
print(messy_row.split())       # ['DevAscent', 'Cohort', '14', 'Active']

# Explicit delimiter split preserves empty substrings
csv_entry = "Raja,,Instructor"
print(csv_entry.split(","))    # ['Raja', '', 'Instructor'] (Empty string preserved)

# Partition: Always returns exactly a 3-tuple: (before, separator, after)
config_pair = "DATABASE_TIMEOUT=60"
key, sep, val = config_pair.partition("=")
print(f"Key: {key} | Val: {val}")  # Key: DATABASE_TIMEOUT | Val: 60

log_message = "CRITICAL: Database connection failed on shard #4"

# 1. find() returns -1 gracefully when missing
if log_message.find("CRITICAL") != -1:
    print("Emergency pager dispatched!")

# 2. Inspection with tuple prefixes / suffixes
endpoint = "https://api.devascent.me/v1/metrics"
print(endpoint.startswith(("http://", "https://")))  # True (Accepts tuple of prefixes!)
print(endpoint.endswith(("/metrics", "/health")))     # True

# 3. Content character validation
print("DevAscent".isalpha())   # True (All alphabetical characters)
print("12345".isdigit())       # True (All decimal digits)
print("var_name_1".isidentifier()) # True (Valid Python identifier token)

# 1. Floating-Point Rounding & Precision
pi = 3.1415926535
print(f"Pi to 2 decimals: {pi:.2f}")          # '3.14'
print(f"Pi to 4 decimals: {pi:.4f}")          # '3.1416'

# 2. Financial Thousand Separators & Percentages
revenue = 12450890.5
completion = 0.8765
print(f"Revenue:    ${revenue:,.2f}")         # '$12,450,890.50'
print(f"Completion: {completion:.1%}")        # '87.7%'

# 3. Positional Alignment & Fill Padding
title = "REPORT"
print(f"|{title:<12}|")                       # '|REPORT      |' (Left aligned)
print(f"|{title:>12}|")                       # '|      REPORT|' (Right aligned)
print(f"|{title:^12}|")                       # '|   REPORT   |' (Centered)
print(f"|{title:*^12}|")                      # '|***REPORT***|' (Fill with '*')

# 4. Binary, Hexadecimal, and Zero Padding
order_num = 42
print(f"Invoice ID: {order_num:06d}")         # '000042' (6-digit zero pad)
print(f"Hex Code:   {order_num:#06x}")        # '0x002a'
print(f"Binary:     {order_num:#010b}")       # '0b00101010'

# Feature 1: The Self-Documenting '=' Debugging Syntax (Python 3.8+)
server_ip = "192.168.1.100"
active_connections = 428
latency_ms = 12.45

print(f"{server_ip=}, {active_connections=}, {latency_ms=:.1f}ms")

# Feature 2: Complex inline expressions & dunder calls
scores = [92, 88, 95]
print(f"Average Grade: {sum(scores) / len(scores):.2f}")

# Feature 3: Python 3.12 (PEP 701) Syntactic Freedom
# In Python 3.12+, quote reuse and backslashes are fully legal inside f-string expressions:
payload = {"user": "DevAscent", "status": "VERIFIED"}
print(f"User Status: {payload[\"status\"].lower()}")  # Clean quotes inside quotes!

"""DevAscent Academy — Unit 4 Capstone Module"""

def sanitize_and_parse_log(raw_log: str) -> dict:
    cleaned = raw_log.strip()
    tokens = [t.strip() for t in cleaned.split("|")]
    if len(tokens) < 5: raise ValueError("Corrupted log packet")
    timestamp, log_level, ip_addr, auth_token, latency_raw = tokens[:5]
    
    # Mask Bearer Token via prefix removal and dual slicing
    if auth_token.startswith("Bearer "):
        body = auth_token.removeprefix("Bearer ")
        masked = f"Bearer {body[:6]}****{body[-4:]}"
    else:
        masked = "INVALID_AUTH_FORMAT"
        
    latency_float = float(latency_raw.removesuffix("ms").strip())
    return {
        "Timestamp": timestamp, "Severity": log_level.upper(),
        "Client_IP": ip_addr, "Token": masked, "Latency_ms": f"{latency_float:.2f} ms"
    }

raw_pkt = "  2026-10-14 22:30:00 | info | 192.168.1.45 | Bearer eyJhbGciOiJIUzI1Ni.xyz | 14.85ms \n\r"
p = sanitize_and_parse_log(raw_pkt)
print(f"[{p['Severity']}] {p['Timestamp']} | IP: {p['Client_IP']} | Latency: {p['Latency_ms']}")
print(f"Sanitized Token: {p['Token']}")