Python Context Managers and ContextVars

Use `type()`, `inspect.isgenerator()`, and `iter(g) is g` to verify that an object is both a generator and an iterator.

Describe a generator object as one particular function execution that can start, pause, remember its state, and continue.

Call `next()` once and observe that the generator starts and pauses at its first `yield`.

Call `next()` again and observe that execution continues immediately after the previous `yield`.

Print changing local variables before each `yield` to verify that their values survive while the generator is paused.

Inspect `g.gi_frame.f_locals` and `g.gi_frame.f_lasti` to find the saved local values and paused instruction position of a generator.

Catch `StopIteration` and use prints to distinguish a paused generator from one that has finished permanently.

Run a small `try/finally` example and verify that `finally` performs cleanup on both normal and error paths.

Write a context manager class with `__enter__` and `__exit__` methods.

Print each step to observe the order of `__enter__`, the `with` body, and `__exit__`.

Return a value from `__enter__` and receive that value after `as` in a `with` statement.

Raise an error in the `with` body and inspect the exception type, value, and traceback received by `__exit__`.

Return `True` and `False` from `__exit__` in separate runs and observe whether the error is suppressed or continues.

Manually call `next()` on a one-yield generator to run setup before `yield` and cleanup after `yield`.

Add `@contextmanager` to the one-yield generator and use it in a `with` statement.

Print each step to connect entering the block with the first generator resume and leaving the block with the second resume.

Yield a value from the generator and receive it after `as` in the `with` statement.

Put `yield` inside `try/finally`, raise an error in the `with` body, and verify that cleanup still runs.

Use `inspect.getsource(contextlib.contextmanager)` to locate where the decorated generator is wrapped in `_GeneratorContextManager`.

Read the relevant `__enter__` and `__exit__` source in the installed `contextlib`, identifying `next()`, `throw()`, and the checks that require exactly one `yield`.

Implement and test a small learning version of the one-yield generator adapter using `next()` on entry and `next()` or `throw()` on exit.

Bind two names to the same list, verify their identity with `is` and `id()`, append through one name, and observe the change through the other.

Rebind a name directly and inside a function, then use identities and printed values to verify that rebinding does not replace the object held by other names.

Create a `ContextVar`, set a value around a nested function call, and read the current value inside that function without passing an argument.

Save the token returned by `ContextVar.set()` and use `reset()` to restore the previous value after nested changes.

Build a small context manager that sets a temporary `ContextVar` value and restores it after both a normal block and a block that raises an error.

Run two deliberately interleaved `asyncio` tasks and verify that each task repeatedly reads its own current value.

Set different values before separate `asyncio.create_task()` calls and verify that each child receives the context current at its creation while later changes remain isolated.

Demonstrate that a `ContextVar` does not inspect the call stack automatically: a caller boundary must set the value before a nested shared service can read it.

Run one shared vendor client across about 20 tasks, set a caller ID at each task boundary, record `(caller_id, cost)` without passing the ID to the client method, and verify the per-caller totals.