24. అడ్వాన్స్‌డ్ పైథాన్ — డెకరేటర్లు, జెనరేటర్లు & డండర్ మెథడ్స్

# ఆపరేటర్ ఓవర్‌లోడింగ్ మరియు పైథాన్ డేటా మోడల్
class Money:
    def __init__(self, amount: float, currency: str = "INR"):
        self.amount = round(float(amount), 2)
        self.currency = currency

    # 1. యూజర్ ఫ్రెండ్లీ స్ట్రింగ్
    def __str__(self):
        symbol = "₹" if self.currency == "INR" else self.currency
        return f"{symbol}{self.amount:,.2f}"

    # 2. డెవలపర్ డీబగ్గింగ్ రిప్రజెంటేషన్
    def __repr__(self):
        return f"Money(amount={self.amount}, currency='{self.currency}')"

    # 3. కూడిక ఆపరేటర్ (+) ఓవర్‌లోడింగ్
    def __add__(self, other):
        if not isinstance(other, Money) or self.currency != other.currency:
            raise TypeError("విభిన్న కరెన్సీలను లేదా నాన్-మనీ ఆబ్జెక్టులను కూడలేము!")
        return Money(self.amount + other.amount, self.currency)

    # 4. గుణకారం ఆపరేటర్ (*) ఓవర్‌లోడింగ్ (స్కేలార్ నంబర్‌తో)
    def __mul__(self, factor: float):
        return Money(self.amount * factor, self.currency)

    # 5. సమానత్వ ఆపరేటర్ (==)
    def __eq__(self, other):
        return isinstance(other, Money) and self.amount == other.amount and self.currency == other.currency

    # 6. తక్కువ/ఎక్కువ ఆపరేటర్ (<) సార్టింగ్ కోసం
    def __lt__(self, other):
        if not isinstance(other, Money) or self.currency != other.currency:
            raise TypeError("పోలిక ఒకే కరెన్సీ మధ్య మాత్రమే సాధ్యం!")
        return self.amount < other.amount

# టెస్టింగ్
m1 = Money(1500, "INR")
m2 = Money(3250.50, "INR")
m3 = m1 + m2
print("m1:", m1)                  # __str__ -> ₹1,500.00
print("repr(m1):", repr(m1))      # __repr__ -> Money(amount=1500.0, currency='INR')
print("మొత్తం (m1 + m2):", m3)    # ₹4,750.50
print("GST తో (m1 * 1.18):", m1 * 1.18)
print("సార్టింగ్ ఫలితం:", sorted([m2, m1]))

import functools
import time

def retry_operation(max_attempts=3, delay_sec=1.0):
    """విఫలమైన ఫంక్షన్లను ఆటోమేటిక్‌గా రీట్రై చేసే డెకరేటర్."""
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            attempts = 0
            while attempts < max_attempts:
                try:
                    attempts += 1
                    return func(*args, **kwargs)
                except Exception as err:
                    print(f"⚠️ [ప్రయత్నం {attempts}/{max_attempts}] విఫలమైంది: {err}")
                    if attempts >= max_attempts:
                        print("❌ గరిష్ట రీట్రై పరిమితి ముగిసింది! ఎర్రర్ విసురుతున్నాము.")
                        raise
                    time.sleep(delay_sec)
        return wrapper
    return decorator

# సిమ్యులేషన్: 2 సార్లు ఫెయిల్ అయి 3వ సారి సక్సెస్ అయ్యే API కాల్
call_count = 0

@retry_operation(max_attempts=3, delay_sec=0.5)
def fetch_payment_status(txn_id: str):
    global call_count
    call_count += 1
    if call_count < 3:
        raise ConnectionResetError("గేట్‌వే సర్వర్ స్పందించడం లేదు (504 Gateway Timeout)")
    return f"SUCCESS: లావాదేవీ {txn_id} విజయవంతంగా పూర్తయింది!"

print("📡 పేమెంట్ సర్వీస్ కాల్ మొదలైంది...")
result = fetch_payment_status("TXN-90218")
print("🎉 రిజల్ట్:", result)

# =====================================================================
# చాప్టర్ 24 ప్రాజెక్ట్: Gigabyte-Scale Streaming Server Log Audit Pipeline
# కాన్సెప్ట్స్: Custom Context Manager, Generators, yield from,
#              Dunder Methods (__iter__, __len__, __repr__), @timer Decorator
# =====================================================================
import time
import functools

# 1. పెర్ఫార్మెన్స్ బెంచ్‌మార్క్ డెకరేటర్
def benchmark_pipeline(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        res = func(*args, **kwargs)
        t1 = time.perf_counter()
        print(f"
⚡ పైప్‌లైన్ ఆడిట్ పూర్తయిన సమయం: {(t1 - t0)*1000:.3f} ms")
        return res
    return wrapper

# 2. లాగ్ రికార్డ్ క్లాస్ (Python Data Model with Dunder Methods)
class LogRecord:
    def __init__(self, ip: str, method: str, path: str, status_code: int, response_ms: float):
        self.ip = ip
        self.method = method
        self.path = path
        self.status_code = status_code
        self.response_ms = response_ms

    def __repr__(self):
        return f"LogRecord({self.ip} | {self.method} {self.path} -> {self.status_code})"

    def is_security_threat(self) -> bool:
        # 401/403/500 ఎర్రర్లు లేదా అనుమానాస్పద పాత్‌లను గుర్తించడం
        suspicious_paths = ["/admin", "/wp-login.php", "/.env", "/config.json"]
        return self.status_code in (401, 403, 500) or any(sp in self.path for sp in suspicious_paths)

# 3. కాంటెక్స్ట్ మేనేజర్: సేఫ్ లాగ్ స్ట్రీమ్ సెషన్
class LogStreamAuditSession:
    def __init__(self, session_name: str):
        self.session_name = session_name

    def __enter__(self):
        print(f"🔒 [AUDIT SESSION: {self.session_name}] సెషన్ ప్రారంభమైంది. లాగ్ స్ట్రీమ్ లాక్ చేయబడింది.")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        if exc_type:
            print(f"🚨 [AUDIT ALERT] సెషన్‌లో ఊహించని ఎర్రర్: {exc_val}")
        print(f"🔓 [AUDIT SESSION: {self.session_name}] సెషన్ సురక్షితంగా క్లోజ్ అయింది.
")
        return False

# 4. జెనరేటర్: భారీ లాగ్ ఫైల్ సిమ్యులేషన్ (మెమరీలో కేవలం 1 లైన్ మాత్రమే ఉంటుంది)
def generate_raw_server_logs():
    raw_sample_data = [
        "192.168.1.10 GET /api/v1/products 200 45.2",
        "10.0.0.5 POST /api/v1/checkout 200 320.1",
        "45.33.32.156 GET /admin 403 12.0",
        "185.220.101.5 GET /wp-login.php 404 8.5",
        "192.168.1.12 GET /api/v1/user/profile 200 65.4",
        "45.33.32.156 POST /api/v1/login 401 25.0",
        "10.0.0.8 GET /config.json 500 110.0",
        "192.168.1.15 GET /index.html 200 18.2"
    ]
    for line in raw_sample_data:
        yield line

# 5. జెనరేటర్ పైప్‌లైన్: రా స్ట్రింగ్‌ను LogRecord ఆబ్జెక్ట్‌గా మార్చడం (Lazy Parsing)
def parse_log_stream(raw_stream):
    for line in raw_stream:
        parts = line.strip().split()
        if len(parts) == 5:
            ip, method, path, status_code, resp_ms = parts
            yield LogRecord(ip, method, path, int(status_code), float(resp_ms))

# 6. జెనరేటర్ ఫిల్టర్: కేవలం సెక్యూరిటీ బెదిరింపులను మాత్రమే ఫిల్టర్ చేయడం
def filter_security_threats(record_stream):
    for record in record_stream:
        if record.is_security_threat():
            yield record

# 7. మొత్తం పైప్‌లైన్ ఎగ్జిక్యూషన్
@benchmark_pipeline
def run_security_audit():
    with LogStreamAuditSession("SOC_HYDERABAD_GATEWAY"):
        raw_stream = generate_raw_server_logs()
        parsed_stream = parse_log_stream(raw_stream)
        threat_stream = filter_security_threats(parsed_stream)

        print("🔍 గుర్తించబడిన భద్రతా బెదిరింపులు (Security Threat Events):")
        threat_count = 0
        for threat in threat_stream:
            threat_count += 1
            print(f"  [హెచ్చరిక #{threat_count}] {threat}")

        print(f"
📊 మొత్తం విశ్లేషించబడిన బెదిరింపుల సంఖ్య: {threat_count}")

# పైప్‌లైన్ రన్ చేద్దాం
run_security_audit()