Error handling ও exception

এই philosophy Python-এ এত গভীর — যে standard library এই pattern-এ লেখা। বুঝলে — Pythonic code লেখা আসে।

Definitions:

• LBYL (Look Before You Leap): কাজ করার আগে condition check।
• EAFP (Easier to Ask Forgiveness): কাজ করো, ব্যর্থ হলে exception ধরো।

Python-এ EAFP কেন preferred?

• Cheap exceptions: exception raise/catch দ্রুত (সাধারণত)।
• Race-condition free: "check then act" — মাঝে state বদলাতে পারে; "act then handle" — atomic।
• Duck typing: "isinstance check" এড়িয়ে — method call করো, fail হলে handle।
• Readability: happy path-এ noise কম।

Race condition উদাহরণ:

# LBYL — race condition!
if os.path.exists("file.txt"):
    # মাঝে অন্য process delete করে দিল
    f = open("file.txt")    # FileNotFoundError

# EAFP — atomic
try:
    f = open("file.txt")
except FileNotFoundError:
    handle_missing()

Performance comparison:

• Common case (no error): EAFP দ্রুত (no check overhead)।
• Common error: LBYL দ্রুত (no exception raise)।
• Python-এ exception cheap, কিন্তু hot loop-এ avoid।

C/Java-এ LBYL কেন preferred?

• Exception expensive (stack unwind, allocation)।
• Static type — compile-time check possible।
• Convention — checked exceptions force LBYL।
• "Exceptions are exceptional" philosophy।

Python idioms — EAFP-এর উদাহরণ:

# Dict lookup
# খারাপ — LBYL
if "key" in d:
    val = d["key"]
else:
    val = default

# ভাল — EAFP
try:
    val = d["key"]
except KeyError:
    val = default

# আরও ভাল — built-in
val = d.get("key", default)

# Attribute access
# ভাল
try:
    name = obj.name
except AttributeError:
    name = "unknown"

# আরও ভাল
name = getattr(obj, "name", "unknown")

কখন LBYL সঠিক?

• Hot loop — performance critical।
• Validation logic clear।
• Error message customization।
• Pre-condition complex।

AI/ML-এ এই philosophy:

• Tensor shape: EAFP — try operation, RuntimeError catch।
• Model loading: EAFP — version mismatch ধরা।
• Data parsing: EAFP — corrupt sample skip।
• GPU OOM: EAFP + retry with smaller batch।

Hybrid approach:

# Validate at boundary (LBYL)
def public_api(x):
    if not isinstance(x, np.ndarray):
        raise TypeError("expected ndarray")

    # Internal logic — EAFP
    try:
        return process(x)
    except (ValueError, RuntimeError) as e:
        log_and_recover(e)

মূল উপলব্ধি: EAFP = "trust, then verify"। Python-এ — duck typing, dynamic, exception cheap → EAFP natural। AI কোডে hybrid: boundary-তে validate, internal-এ EAFP। Robustness comes from embracing failure, not avoiding।

Exception handling-এ specificity = correctness। Broad catch = silent bug = production disaster।

Bare except — প্রায় সবসময় ভুল:

# বিপজ্জনক
try:
    risky_op()
except:               # সব ধরে — KeyboardInterrupt, SystemExit-ও!
    pass

# খুব খারাপ —
# - Ctrl+C কাজ করে না
# - sys.exit() block হয়
# - bug masked
# - debugging impossible

Hierarchy understanding:

BaseException
  ├── KeyboardInterrupt    # user Ctrl+C
  ├── SystemExit           # sys.exit()
  ├── GeneratorExit
  └── Exception            # 99% practical errors
       ├── ValueError
       ├── TypeError
       ├── KeyError
       ├── ...

Best practices ranked:

1. Specific: except FileNotFoundError: — perfect।
2. Group: except (ValueError, TypeError): — multiple।
3. Domain: except IOError: — class hierarchy।
4. Last resort: except Exception as e: — log + re-raise।
5. Never: except: বা except BaseException:

Pattern: log + re-raise:

import logging

try:
    train_model()
except Exception as e:
    logging.exception("Training failed")    # full traceback
    raise                                    # উপরে চলে যাক

Silent failure-এর AI catastrophes:

• NaN gradient swallowed: training "চলছে" দেখায়, model garbage।
• Data validation skip: bad sample silently dropped → biased model।
• Checkpoint save failure: ১০ ঘণ্টা training, save fail, পরের run scratch।
• GPU memory leak hidden: performance degrade, root cause obscure।
• Tokenizer error masked: wrong tokens → wrong model।

"Don't catch, log" rule:

• Catch → handle meaningfully → re-raise বা return error।
• Catch → ignore → BUG MASKED।
• "Pass" inside except = code smell।

Modern Python improvements:

• Python 3.11 — Exception groups (except*)।
• Python 3.11 — fine-grained traceback।
• Notes on exceptions (e.add_note)।

Production patterns:

# Retry with backoff
from time import sleep

def with_retry(func, retries=3):
    for attempt in range(retries):
        try:
            return func()
        except (ConnectionError, TimeoutError) as e:
            if attempt == retries - 1:
                raise
            sleep(2 ** attempt)            # exponential backoff
            logging.warning(f"Retry {attempt + 1}: {e}")

Sentinel value vs exception:

• None/-1 return — caller must check।
• Exception — uncaught propagates。
• Result type (Rust style) — explicit success/error।
• AI-তে: data parsing-এ Result/Option pattern jaa৵o popular।

মূল উপলব্ধি: "Catch the exception you can handle, propagate the rest." Specific catch = clear intent। Bare/broad catch = bug factory। AI long-running training-এ exception handling discipline = সাফল্যের শর্ত।

Custom exception = domain-specific contract। Library design-এ এটা mature engineering-এর hallmark।

Built-in vs custom:

• Built-in (ValueError, KeyError) — Python-এর core জিনিস।
• Custom — আপনার domain-এর জিনিস।

সুবিধা:

• Specific catch: caller সঠিক handler লিখতে পারে।
• Rich context: attributes (epoch, batch, layer)।
• Documentation: error type-ই docs।
• Testing: assertRaises-এ specific check।
• Hierarchy: general → specific catch।

Hierarchy design pattern:

class MLError(Exception):
    """Base — সব ML error-এর জন্য."""

class TrainingError(MLError):
    """Training stage."""

class NaNLossError(TrainingError):
    def __init__(self, epoch, batch):
        self.epoch = epoch
        self.batch = batch
        super().__init__(f"NaN at epoch {epoch}, batch {batch}")

class ConvergenceError(TrainingError):
    def __init__(self, final_loss, threshold):
        self.final_loss = final_loss
        self.threshold = threshold
        super().__init__(
            f"Loss {final_loss:.4f} > threshold {threshold:.4f}"
        )

class DataError(MLError):
    """Dataset-related."""

class SchemaMismatchError(DataError):
    pass

ব্যবহার hierarchy-এর সুবিধা:

# Specific
try:
    train()
except NaNLossError as e:
    print(f"NaN at {e.epoch}/{e.batch} — reduce lr")
except ConvergenceError as e:
    print(f"Did not converge: {e.final_loss}")

# General fallback
try:
    pipeline()
except MLError as e:
    notify_team(e)
except Exception:
    raise                # not ours, bubble up

AI library examples:

• PyTorch: torch.cuda.OutOfMemoryError, RuntimeError with shape info।
• HuggingFace: OSError for model not found, custom RepositoryNotFoundError।
• Pydantic: ValidationError with field-level details।
• scikit-learn: NotFittedError, ConvergenceWarning।
• JAX: TracerArrayConversionError — JIT-specific।

Design principles:

• Inherit appropriately: file error → IOError; bad value → ValueError।
• Rich attributes: just message না, structured data।
• Helpful message: "RuntimeError" না, "expected shape (3,4), got (4,3)"।
• Avoid over-hierarchy: ৩-৪ level যথেষ্ট।
• Public exceptions documented।

Anti-pattern:

# খারাপ — generic
raise Exception("something failed")

# ভাল
raise NaNLossError(epoch=10, batch=100)

Exception chaining (Python 3+):

try:
    parse_csv(path)
except CSVError as e:
    raise DataError(f"Failed to load {path}") from e
# 'from e' preserves original cause

মূল উপলব্ধি: Custom exception = domain language। ভাল library mature হয় তার exception hierarchy দিয়ে। Beginner ব্যবহার করেন built-in; পেশাদার লেখেন custom। Caller-এর জন্য — exception type = এক ধরনের API।

এই প্রশ্ন performance ও correctness-এর সীমান্তে। ভুল সিদ্ধান্ত production AI inference-এ ১০× slowdown।

Exception cost — দু'টি অংশ:

• try block setup: Python 3.11+-এ প্রায় free (zero-cost exception)।
• Exception raise + handle: expensive — stack unwind, frame inspection, traceback।

Benchmark perspective:

import timeit

# try block alone (no exception)
def with_try():
    try:
        x = 1 + 1
    except:
        pass

# Without
def without_try():
    x = 1 + 1

# Difference: ~5-10% (Python 3.10), nearly 0 (3.11+)

Exception raise:

# Raising → expensive
def raises():
    try:
        raise ValueError()
    except:
        pass
# ~১০-৫০× slower than no exception

Hot loop — কখন avoid:

• Inner loop, millions iterations।
• Exception যদি common (>1%) হয়।
• Inference per-request critical।

Hot loop-এ alternatives:

# খারাপ — exception in hot loop
for x in big_list:
    try:
        result = d[x]
    except KeyError:
        result = default

# ভাল — dict.get
for x in big_list:
    result = d.get(x, default)

# আরও ভাল — pre-filter
valid = [x for x in big_list if x in d]
for x in valid:
    result = d[x]

AI inference impact:

• Model serving — latency-sensitive (10-100 ms budget)।
• Per-request try/except — minimal impact (single try block)।
• Per-token try/except (LLM generation) — measurable।
• Validation pre-loop > exception in loop।

Profile-driven optimization:

import cProfile

cProfile.run("inference_loop()", sort="cumulative")
# Look for raise/except hotspots

Python 3.11 — zero-cost exceptions:

• PEP 657 — try block-এ no overhead যদি exception raise না হয়।
• Bytecode-level optimization।
• Common case (no error) এখন সত্যিই free।

Cython/C-extension consideration:

• NumPy/PyTorch — internal C, exception only at boundary।
• Vectorized ops — exception per element নয়, batch validate।

Modern best practice:

• Don't pre-optimize — exception cost rarely bottleneck।
• Profile first — actual hotspot find।
• Validate at boundary, not per-element।
• Hot inference — minimize per-iteration overhead overall।

Logging cost:

• logging.exception() — full traceback expensive।
• Hot path-এ — debug log gate করুন।
• Sampling logging in production।

Real-world examples:

• OpenAI API — request validation outer try।
• PyTorch DataLoader — sample-level exception catch (not per-element)।
• FastAPI — middleware-level exception handler।

মূল উপলব্ধি: Exception cost = "raising" + "handling"। Try block-এ থাকা cheap (especially 3.11+)। Common path-এ exception ঘটানো expensive। AI inference-এ — boundary validation + EAFP at boundary, vectorize within। Profile, don't guess।