Remember David L. Parnas’s saying that a module is an abstraction, and according to Edsger Dijkstra, the purpose of abstraction is to create a new semantic level in which one can be absolutely precise. Introducing an explicit integration contract takes this idea to the extreme. The integration contract can create a new language that focuses entirely on the tasks that can be carried out using the module, while completely abstracting how the tasks are implemented

DISCLAIMER: THIS IS NOT AN EXACT SCIENCE

from ctypes import c_byte
from sys import getsizeof


def set_value(old: object, new: object) -> None:
    src_s, des_s = getsizeof(new), getsizeof(old)
    src_arr = (c_byte * src_s).from_address(id(new))
    des_arr = (c_byte * des_s).from_address(id(old))
    des_arr[:] = src_arr[:]


set_value('a', 'z')

assert 'a' == 'z'

C++ and Java developers expect to be able to run a program at full speed (or very close to it) under a debugger. Python developers should expect that too.

import sys
import random
import asyncio

from types import CodeType
from contextlib import contextmanager


@contextmanager
def log_cpython_vm_events(events_callbacks: dict):
    if len(events_callbacks) > 5:
        raise ValueError("Too many events callbacks")

    try:
        for tool_id, (event, callback) in enumerate(events_callbacks.items(), start=1):
            sys.monitoring.use_tool_id(tool_id, "test")
            sys.monitoring.register_callback(tool_id, event, callback)
            sys.monitoring.set_events(tool_id, event)
        yield
    finally:
        for tool_id, (event, callback) in enumerate(events_callbacks.items()):
            sys.monitoring.register_callback(tool_id, event, None)
            sys.monitoring.free_tool_id(tool_id)


def callback_on_yield(code: CodeType, instruction_offset: int, retval: object):
    next_frame = sys._getframe(1)
    print(
        f'Yield from "{code.co_name}" with locals={next_frame.f_locals} witch return instance id={id(retval)} of type {type(retval).__name__}'
    )


def callback_on_stop_iteration(
    code: CodeType, instruction_offset: int, exception: object
):
    next_frame = sys._getframe(1)
    print(
        f'Stop iteration from "{code.co_name}" with locals={next_frame.f_locals} witch raise exc "{type(exception).__name__}"'
    )


EVENTS_CALLBACKS_MAPPING = {
    sys.monitoring.events.PY_YIELD: callback_on_yield,
    sys.monitoring.events.STOP_ITERATION: callback_on_stop_iteration,
}


async def run(idx: int):
    await asyncio.sleep(random.random())


async def main():
    await asyncio.gather(*map(run, range(2)))


with log_cpython_vm_events(EVENTS_CALLBACKS_MAPPING):
    asyncio.run(main())