Unit 3: Operators & Expressions

# True Division yields float; Floor Division rounds towards -infinity
print(7 / 2, 6 / 2)     # 3.5, 3.0 (True division always yields float)
print(7 // 2)          # 3 (Positive truncation)
print(-7 // 2)         # -4 (Mathematical floor: -3.5 rounds down to -4!)

# Binary floating-point representation dilemma & solutions
print(0.1 + 0.2 == 0.3)                  # False! (Raw float is 0.30000000000000004)

import math
print(math.isclose(0.1 + 0.2, 0.3))     # True (Scientific tolerance)

from decimal import Decimal
price = Decimal("0.10") + Decimal("0.20")
print(price == Decimal("0.30"))          # True (Exact base-10 fintech precision)

servers = ["server-us-east", "server-eu-west", "server-ap-south"]

# Distribute 4 incoming requests across 3 servers cyclically
for req_id in range(4):
    assigned = servers[req_id % len(servers)]
    print(f"Req #{req_id} -> {assigned}")

# High-performance built-in divmod(x, y) returns (quotient, remainder) in 1 C-call
quotient, remainder = divmod(125, 60)
print(f"125s = {quotient}m and {remainder}s")  # 2m and 5s

# Case 1: Standard addition creates a BRAND NEW list in memory!
list_a = [1, 2]
old_id = id(list_a)
list_a = list_a + [3]
print(id(list_a) == old_id)   # False (New object allocated in heap!)

# Case 2: Augmented += modifies the list IN-PLACE via __iadd__!
list_b = [1, 2]
old_id = id(list_b)
list_b += [3]
print(id(list_b) == old_id)   # True! (Same memory address, zero reallocation)

# Read terminal commands until user types 'exit'
while (command := input("DevAscent-CLI> ").strip().lower()) != "exit":
    print(f"Dispatching task: {command}")

print("Session terminated gracefully.")

import re
auth_header = "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"

# Extract and bind regex match object in a single conditional line
if (match := re.match(r"^Bearer\s+([A-Za-z0-9\-_\.]+)", auth_header)):
    token = match.group(1)
    print(f"JWT Token Verified: {token[:16]}...")

# Uppercase 'A' (65) is less than lowercase 'a' (97)!
print("Apple" < "apple")   # True (ord('A')=65 < ord('a')=97)

# Alphabetical sorting order
print("FastAPI" < "Flask")  # True ('a' comes before 'l')

# Custom object comparison requires implementing __eq__ or __lt__
class Student:
    def __init__(self, score): self.score = score
    def __eq__(self, other): return self.score == other.score

s1, s2 = Student(95), Student(95)
print(s1 == s2)             # True (Dunder __eq__ intercepted comparison)

# The IEEE 754 NaN anomaly: NaN is NEVER equal to anything, including itself!
nan_val = float("nan")
print(nan_val == nan_val)   # False! Always verify via math.isnan()

score = 85

# Highly readable, mathematically elegant
if 70 <= score <= 100:
    print("Candidate eligible for Distinction Honors")

# Multi-term equality chaining
a = b = c = 10
print(a == b == c)   # True

# Chaining with directional transitions
print(5 < 10 > 2)    # True (Equivalent to: (5 < 10) and (10 > 2))

# 'or' returns first Truthy operand
print("DevAscent" or "Default")  # 'DevAscent'
print("" or "Fallback API")       # 'Fallback API'
print([] or [1, 2, 3])             # [1, 2, 3]

# 'and' returns first Falsy operand, or last Truthy operand
print(0 and 100)                 # 0
print(42 and "Active")           # 'Active'

user_profile = None

# Safe guard: user_profile is None, so Python short-circuits and never executes
# user_profile['email'], preventing a fatal TypeError: 'NoneType' object is not subscriptable!
if user_profile is not None and user_profile["email"]:
    print("Email verified.")
else:
    print("No active profile detected.")

# Define permission powers of 2 using Left-Shift
READ    = 1 << 0   # 0001 (1)
WRITE   = 1 << 1   # 0010 (2)
EXECUTE = 1 << 2   # 0100 (4)
ADMIN   = 1 << 3   # 1000 (8)

# 1. Granting permissions using Bitwise OR (|)
student_role = READ | EXECUTE              # 0101 (5)
instructor_role = READ | WRITE | EXECUTE   # 0111 (7)

# 2. Checking permissions using Bitwise AND (&)
def has_permission(role, perm):
    return (role & perm) == perm

print(f"Student can write?    {has_permission(student_role, WRITE)}")      # False
print(f"Instructor can write? {has_permission(instructor_role, WRITE)}")  # True

# 3. Revoking permissions using Bitwise AND with NOT (& ~)
instructor_role &= ~WRITE  # Strips the WRITE bit cleanly
print(f"Instructor write after revocation: {has_permission(instructor_role, WRITE)}")

# 4. Toggling permissions using Bitwise XOR (^)
student_role ^= EXECUTE   # Flips EXECUTE from active to inactive

# 1. String Substring Match
announcement = "Cohort #14 enrollments are now live on devascentacademy.me"
print("Cohort #14" in announcement)      # True

# 2. List Membership
active_courses = ["Python", "AI", "Web Dev"]
print("Rust" not in active_courses)       # True

# 3. Dictionary Membership checks KEYS by default!
student = {"name": "Raja Mishra", "role": "STUDENT"}
print("name" in student)                 # True (Checks key)
print("Raja Mishra" in student)          # False! (Does not check values by default)
print("Raja Mishra" in student.values()) # True (Explicitly search values)

# ALWAYS use 'is' when checking against None (PEP 8 requirement)
api_response = None

if api_response is None:
    print("Waiting for backend telemetry...")

# NEVER use 'is' for numerical or string equality!
a = 1000
b = 1000
# print(a is b)  <-- Unreliable! Depends on compiler memory caching optimization!
print(a == b)    # Guaranteed True (Accurate value comparison)

# Trap 1: Exponentiation evaluates from RIGHT to LEFT:
print(2 ** 3 ** 2)      # 512! (Computed as: 2 ** (3 ** 2) = 2 ** 9)
# NOT: (2 ** 3) ** 2 = 8 ** 2 = 64

# Trap 2: Unary Minus vs Exponentiation
print(-2 ** 2)          # -4! (Computed as: -(2 ** 2))
# Parentheses mandatory for negative base: (-2) ** 2 = 4

# Trap 3: Bitwise vs Comparison precedence ('==' binds tighter than '&'!)
flags = 0b0101
MASK  = 0b0001
# if flags & MASK == 1: <-- Parsed as: flags & (MASK == 1) -> flags & True -> 1!
if (flags & MASK) == 1: # Correct: Explicit parentheses eliminate ambiguity
    print("Mask bit confirmed.")

# Trap 4: Logical 'and' binds tighter than 'or'
print(True or False and False)  # True! Parsed as: True or (False and False)

"""DevAscent Academy — Unit 3 Capstone Module"""

FLAG_ENCRYPTED  = 1 << 0  # 1
FLAG_SIGNED     = 1 << 1  # 2
FLAG_COMPRESSED = 1 << 2  # 4

APPROVED_REGIONS = {"ap-south-1", "us-east-1", "eu-central-1"}

def validate_telemetry_packet(packet: dict) -> bool:
    # 1. Membership checking (O(1) hash lookup)
    if packet.get("region") not in APPROVED_REGIONS:
        return False
        
    # 2. Chained comparison for thermal limits and payload size
    temp_c = packet.get("temperature_c", 0.0)
    size_kb = packet.get("payload_size_kb", 0)
    if not (-40.0 <= temp_c <= 85.0) or not (0 < size_kb <= 1024):
        return False
        
    # 3. Bitwise verification: Must be both ENCRYPTED and SIGNED
    flags = packet.get("security_flags", 0)
    required_flags = FLAG_ENCRYPTED | FLAG_SIGNED
    return (flags & required_flags) == required_flags

# Test Execution
pkt1 = {"region": "ap-south-1", "temperature_c": 32.4, "payload_size_kb": 256, "security_flags": 7}
pkt2 = {"region": "ap-south-1", "temperature_c": 105.0, "payload_size_kb": 64, "security_flags": 7}

print(f"Packet 1 (Standard): {validate_telemetry_packet(pkt1)}")
print(f"Packet 2 (Overheat): {validate_telemetry_packet(pkt2)}")