server = "Prod-Web-01"
cpu_usage = 94.5

# Task: Print "ALERT: Prod-Web-01 is at 94.5% capacity!"
message = f"ALERT: {server} is at {cpu_usage}% capacity!"
print(message)

port_data = [("SSH", 22), ("HTTP", 80), ("HTTPS", 443)]

print(f"{'SERVICE':<10} | {'PORT':<5}")
print("-" * 18)
for service, port in port_data:
    print(f"{service:<10} | {port:<5}")

base_cost = 500.00
tax_rate = 0.10

# Task: Calculate total and format to 2 decimal places
print(f"Base: ${base_cost:.2f}")
print(f"Total (inc. tax): ${base_cost * (1 + tax_rate):.2f}")

daily_cost = 45.50
days = 365

# Calculation inside the f-string
print(f"Estimated Yearly Budget: ${daily_cost * days:,.2f}")
# Output: Estimated Yearly Budget: $16,607.50

services = [("Nginx", "Running"), ("Docker", "Stopped"), ("K8s", "Running")]

print(f"{'SERVICE':<10} | {'STATUS':>10}")
print("-" * 23)

for name, status in services:
    print(f"{name:<10} | {status:>10}")

user = "dev_admin"
role = "read-write"

# We use {{ to escape the braces so they appear in the final string
json_payload = f'{{"username": "{user}", "permissions": "{role}"}}'

print(f"Sending payload: {json_payload}")
# Output: Sending payload: {"username": "dev_admin", "permissions": "read-write"}

log_entry = "2026-01-29T14:30:05Z"

# 1. Extract Year (Start to index 4)
year = log_entry[:4]

# 2. Extract Time (From 11 to 19)
time = log_entry[11:19]

print(f"Audit Date: {year}, Audit Time: {time}")

filename = "system_vulnerability_report_final_v1.pdf"

# Use negative slicing to get the last 3 chars
extension = filename[-3:]

if extension == "pdf":
    print("Document analysis triggered...")
elif extension == "exe":
    print("ALERT: Executable detected!")

data = ["HEADER", "192.168.1.1", "10.0.0.5", "172.16.0.2", "FOOTER"]

# Symmetrical slice to 'trim' the ends
clean_ips = data[1:-1]

print(f"Cleaned IP List: {clean_ips}")

image_path = "ghcr.io/devsecops/web-app:v2.4.1-beta"

# 1. Find the position of the colon
colon_pos = image_path.find(":")

# 2. Slice from colon_pos + 1 to the end
tag = image_path[colon_pos + 1:]

print(f"Deploying Version: {tag}")

events = ["Login", "File_Edit", "File_Delete", "Logout", "Admin_Access"]

# The "Pythonic" reversal trick
reversed_events = events[::-1]

print(f"Latest activity first: {reversed_events}")

# Raw, messy log entry from a server
raw_log = "  ERROR: Connection failed from IP 192.168.1.1  \n"

# 1. Clean whitespace
clean_log = raw_log.strip()

# 2. Check if it's an error
is_error = clean_log.startswith("ERROR")

# 3. Extract the IP (The Architect way)
log_parts = clean_log.split(" ")
ip_address = log_parts[-1]

print(f"Status: {is_error}, IP: {ip_address}")

raw_configs = ["  Max_Connections  ", "timeout ", "  RETRY_COUNT", "Buffer Size  "]

# Your Code Here:
for config in raw_configs:
    # 1. Strip spaces
    # 2. Convert to lowercase
    # 3. Replace spaces with underscores
    clean_config = config.strip().lower().replace(" ", "_")
    print(f"Validated: '{clean_config}'")

api_key = "prod_9283746551029384756"

# Logic:
# 1. Get the first 4 chars
# 2. Get the last 4 chars
# 3. Use .count() to see how many chars to mask (optional) or use string slicing
# 4. Join them with "********"

prefix = api_key[:4]
suffix = api_key[-4:]
masked_key = prefix + "*" * 10 + suffix

print(f"Logging Access for Key: {masked_key}")

def is_input_safe(user_input):
    # Normalize input for checking
    check_val = user_input.upper()
    
    # Check for keywords
    if "DROP" in check_val or "DELETE" in check_val:
        return False
    
    # Check for suspicious symbols
    if ";" in user_input or "--" in user_input:
        return False
        
    return True

# Test cases
print(is_input_safe("admin' --"))      # Should be False
print(is_input_safe("john_doe_2026"))  # Should be True

access_log = "amit_sharma,Security_Admin,Mumbai,Infrastructure"

# 1. Split by comma
data = access_log.split(",")

# 2. Assign variables via indexing
username = data[0]
role = data[1]
dept = data[-1]

print(f"User {username} from {dept} is requesting {role} access.")

files = ["backup.zip", "install.sh", "script.py", "virus.exe", "notes.txt"]
dangerous_files = []

for file in files:
    if file.endswith((".sh", ".py", ".exe")):
        dangerous_files.append(file)

print(f"Files to audit: {dangerous_files}")

# Inputs
db_host = "192.168.1.50"
db_port = 5432
# Note: Raw string used here because of backslashes in path
db_path = r"D:\Data\Systems\db_vol" 
# Note: Standard string used, but we must be careful if it had quotes
db_pass = "Secure#Pass123"

# Creating the Connection String using f-string (The best way)
connection_string = f"""
[Database Config]
Host: {db_host}
Port: {db_port}
Path: {db_path}
Password: {db_pass}
Status: Active
"""

print(connection_string)

[Database Config]
Host: 192.168.1.50
Port: 5432
Path: D:\Data\Systems\db_vol
Password: Secure#Pass123
Status: Active

# 1. Take dirty input (simulating user typing)
raw_name = "  raHul  "
raw_country = "  india "

print(f"Raw Input: '{raw_name}' and '{raw_country}'")

# 2. Clean and Format
# strip() removes spaces, title() fixes capitalization
clean_name = raw_name.strip().title() 

# strip() removes spaces, upper() capitalizes everything (standard for country codes)
clean_country = raw_country.strip().upper()

# 3. Generate Output
welcome_msg = f"Welcome, {clean_name}! Registration for {clean_country} is complete."

print(welcome_msg)
# Expected Output: Welcome, Rahul! Registration for INDIA is complete.

log_line = "INFO 2026-01-25 [Server-1] TransactionID:TXN-998877 completed successfully."

# 1. Find the starting position
# We look for the label "TransactionID:"
start_marker = "TransactionID:"
start_index = log_line.find(start_marker)

# 2. Calculate the exact start of the value
# We add the length of the marker so we start reading AFTER the colon
value_start = start_index + len(start_marker)

# 3. Find the ending position
# The ID ends where the next space begins
end_index = log_line.find(" ", value_start)

# 4. Slice the string
txn_id = log_line[value_start:end_index]

print(f"Extracted ID: {txn_id}")

# 5. Validation Check
if txn_id.startswith("TXN"):
    print("Valid Transaction format.")
else:
    print("Invalid format!")

# Dangerous input mimicking a hacker
user_input = "admin' OR '1'='1"

print(f"Malicious Input: {user_input}")

# 1. Detect Threat
# logic: if a single quote exists, it is risky
if "'" in user_input:
    print("WARNING: SQL Injection attempt detected!")
    
    # 2. Sanitize (Neutralize the threat)
    # We replace the single quote with an empty string (delete it)
    safe_input = user_input.replace("'", "")
    
    print(f"Sanitized Input: {safe_input}")
    
else:
    print(f"Input is safe: {user_input}")

# Result: The script processes "admin OR 1=1", which effectively breaks the attack logic.

# Configuration Variables
app_name = "payment-service"
image_version = "v2.5.0"
container_port = 8080
env_type = "Production"

# Creating the YAML Manifest
# We use triple quotes (""") to keep the indentation (crucial for YAML)
k8s_manifest = f"""
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {app_name}
  labels:
    env: {env_type}
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: {app_name}
        image: myrepo/{app_name}:{image_version}
        ports:
        - containerPort: {container_port}
"""

print("--- Generated Kubernetes Manifest ---")
print(k8s_manifest)

# Note: In a real script, you would write this string to a file like 'deployment.yaml'

# Lab Code

# 1. Old String
old_log = "server-production-01"
print(f"Original: {old_log} | ID: {id(old_log)}")

# 2. Transformation (Since we can't do old_log[0:6] = "SRV")
# We use slicing to keep everything AFTER index 6 ("-production-01")
remaining_part = old_log[6:] 

# Construct New String
new_log = "SRV" + remaining_part

# 3. Verification
print(f"Fixed:    {new_log} | ID: {id(new_log)}")

# Logic Check
if id(old_log) != id(new_log):
    print("Success: A new immutable string object was created.")
else:
    print("Error: IDs match.")

# Lab 1: The Identity Check
user_role = "admin"
print(f"Original Role: {user_role} | Memory Address: {id(user_role)}")

# Attempt to 'modify' (concatenation)
user_role = user_role + "_sys"
print(f"New Role:      {user_role} | Memory Address: {id(user_role)}")

# Observation: The memory addresses are totally different. 
# Proof: The original "admin" string was NOT changed; a new "admin_sys" was created.

# Lab 2: The Strength Checker
password = "SecurePass123!"
digit_count = 0

# Iterating through the string character by character
for char in password:
    # Check if the character is a number
    if char.isdigit():
        digit_count += 1

print(f"Password '{password}' contains {digit_count} numbers.")
# Output: Password 'SecurePass123!' contains 3 numbers.

# Lab 3: The Order Extractor
# Standard Format: [Date] [Level] Message
log_entry = "[2026-01-28] [ERROR] DB Connection Failed"

# Because strings are ordered, we know exactly where the Date is relative to brackets
date_part = log_entry[1:11] 
print(f"Date of Incident: {date_part}")
# Output: 2026-01-28

# Lab 1 Solution

api_key = "SK_live_51Mz9AaT7bCq8Zp2"

# 1. Slice the Start (Indices 0 to 3)
prefix = api_key[0:4] 

# 2. Slice the End (Last 4 characters)
suffix = api_key[-4:]

# 3. Calculate masking length
# Total length - (length of prefix + length of suffix)
mask_length = len(api_key) - (len(prefix) + len(suffix))

# 4. Construct the NEW string (Concatenation)
masked_key = prefix + ("*" * mask_length) + suffix

print(f"Original: {api_key}")
print(f"Masked:   {masked_key}")

# Verification of Immutability:
# api_key is still the same. 'masked_key' is a new object.
print(f"Original is untouched: {api_key}")

# Lab 2 Solution

permissions = "rwxrwxrwx"
write_count = 0

# 1. Iterate through the string
for char in permissions:
    # 2. Check condition
    if char == 'w':
        write_count = write_count + 1

# 3. Decision Logic
print(f"Analyzing permissions: {permissions}")

if write_count > 1:
    print(f"SECURITY ALERT: Write permission found {write_count} times! Too dangerous.")
else:
    print("Permissions look safe.")

# Lab 3 Solution

filename = "backup_2026_v1.tar.gz"

# We know the format:
# b a c k u p _ 2 0 2 6 ...
# 0 1 2 3 4 5 6 7 8 9 10

# The year starts at index 7 and ends at index 11 (exclusive)
year = filename[7:11]

print(f"Processing File: {filename}")
print(f"Extracted Year: {year}")

# Advanced Architect Tip: 
# If the filename length changes, slicing by hard numbers is risky. 
# Better to use .split('_') if the separator is consistent.
parts = filename.split('_') # ['backup', '2026', 'v1.tar.gz']
print(f"Safer Extraction: {parts[1]}")

# Lab 4 Solution

message = "DevSecOps"

# 1. Reverse the string using negative step slicing
# Syntax: [start : end : step]
# Step -1 means "walk backwards"
encrypted = message[::-1]

print(f"Original:  {message}")
print(f"Encrypted: {encrypted}")

# 2. Decrypt (Reverse the reversed string)
decrypted = encrypted[::-1]

print(f"Decrypted: {decrypted}")

# Validation
if message == decrypted:
    print("Integrity Check Passed.")