X'inhuma context managers u l-istqarrija with?

Question

Accepted Answer

**Context manager** huwa oġġett li jiddefinixxi loġika ta' setup u teardown, użat mal-istqarrija **`with`**. Huwa jiggarantixxi li l-cleanup (għeluq ta' fajls, ħruġ ta' locks, rollback ta' transazzjonijiet) jiġri awtomatikament — anki jekk iseħħ żball.

## Il-problema li tusolvi

```python
# ❌ manual cleanup — error-prone; if processing throws, the file never closes
f = open("file.txt")
data = f.read()
process(data)        # if this raises, f.close() below is skipped → leaked file handle
f.close()

# ✅ with statement — guarantees the file is closed, no matter what
with open("file.txt") as f:
    data = f.read()
    process(data)
# f is automatically closed here — even if process() raised an exception
```

Il-blokk `with` jiżgura li `f.close()` taħdem meta l-blokk joħroġ, kemm normalment kif ukoll permezz ta' eċċezzjoni — u b'hekk jelimina r-riżorsi mwaqqgħin mill-cleanup mixtija jew miskantata.

## Context managers komuni

```python
with open("f.txt") as f: ...           # files (auto-close)
with lock:                              # threading locks (auto-release)
    shared_resource += 1
with db.transaction():                  # DB transactions (auto-commit/rollback)
    ...
with open("a") as a, open("b") as b:    # multiple at once
    ...
```

## Tikteb tiegħek stess — il-mod ta' class

```python
class Timer:
    def __enter__(self):                 # SETUP — runs at `with` entry
        self.start = time.perf_counter()
        return self                       # the value bound to `as`
    def __exit__(self, exc_type, exc_val, tb):  # TEARDOWN — runs at exit (even on error)
        print(f"took {time.perf_counter() - self.start:.3f}s")
        # return False → propagate any exception; True → suppress it

with Timer():
    do_work()
```

Context manager iImplementa `__enter__` (setup) u `__exit__` (cleanup, li jirċiebi kwalunkwe informazzjoni ta' eċċezzjoni).

## Il-mod eħfef — contextlib

```python
from contextlib import contextmanager

@contextmanager
def timer():
    start = time.perf_counter()
    try:
        yield                            # everything before yield = setup; after = teardown
    finally:
        print(f"took {time.perf_counter() - start:.3f}s")

with timer():
    do_work()
```

Id-decorator `@contextmanager` jittrasforna generator f'context manager — setup qabel `yield`, cleanup wara (f' `finally` għas-sigurtà).

## Għaliex importa

Context managers u `with` huma l-mod Pythonic biex tħandle **resource management b'sigurtà** — jiġgarantizzaw li l-fajls jingħalqu, locks jitħallew ħielsa, connections jitħallew, u transazzjonijiet jispiċċaw, anki meta seħħu eċċezzjonijiet.

Da jipprevjeni l-ħassil tal-ġewwieni u stat inkonsistenti, sors komuni ta' bugs mal-cleanup manual.

Jintużaw kostantement (kull operazzjoni ta' fajl għandha tuża `with`), u l-għarfien ta' kif tikteb tiegħek stess (permezz ta' `__enter__`/`__exit__` jew il-mod eħfef `@contextmanager`) jigħtik il-ħila tħaffer kwalunkwe pattern ta' setup/teardown b'mod nadif u affidabbli.