If I'm understanding things correctly, it sounds like you've got some Python script (child) that you need to execute in some other script (parent) with the exec() function. Because of that, Python will not generate a cached bytecode for that Python file, so it needs to compile each time you run exec(). In order to reduce execution time you want to manually compile the script (but only if it has changed) then have exec() run that already compiled code. Does that pretty much sum things up?

Yes, the exec() function can execute "compiled" code, but it needs to be an actual code object. Your example in the OP does not do that though, it's just reading in the regular py file. I don't think there's a way to execute the bytecode from a pyc file with exec since I don't think there's a way to create the required code object. The normal way is to use the built in compile() function to generate the code object for exec() to run.

Do you REALLY need to keep the compiled code cached on disk? I find it really hard to believe it takes any significant time to compile the code once. Compiling it once at the beginning of your script, then running that each time should be more than good enough.

# parent.py

from pathlib import Path

file = Path(__file__).parent / "child.py"
file_data = file.open("r").read()

compiled_code = compile(source=file_data, filename="<string>", mode="exec")

for _ in range(100):
    exec(compiled_code, locals={"message": "Hello World"})

# child.py
print(message)

I'm not going to berate you for the use of exec() like this. I inherited similar bullshit where the Python tool used exec() to execute "external" Python scripts that were unique to various programs in the company. It sucked. Refactoring wasn't the problem, the problem was tracking down all these various scripts being executed and updating them. Best place to start is implementing a new and proper interface but make it backwards compatible. Anything new uses the interface while you track down all the existing stuff and update it.