Why do we proof the halting problem with turing machines?
You could totally do that, but there are some consequences it's worth being aware of.

TM proofs only show difficulty of the halting problem for TMs, but here's a crucial thing that you might be overlooking: it is easy to implement a simulator of a TM in any language of one's choice.  That can probably be done in a few dozen lines of code and it is conceptually straightforward.  This lets us very easily see that the halting problem is also hard in those other languages, too.
The same is not true for Python.  You can't write a Python interpreter in a few dozen lines of code.

Let me try it another way.
Some languages don't have a __file__ global variable or anything with similar semantics.  That makes it unclear whether your result applies to other languages.
Sure, we could try to write down a reduction.  In some other language, we could build a Python interpreter that supports __file__.  But that's not a trivial exercise!  We might need to implement a filesystem, library functions that interact with the filesystem, a parser for Python code, an interpreter for Python code, and so on.  Nothing you can code up in a few hours, and it's not trivial to construct such a reduction.

Now, sure, your argument does work, so it's just a matter of taste which you prefer.  I am showing you some reasons why someone might prefer the TM proof.  If you prefer the Python proof, that's fine.  That's your choice. I just want you to be aware of the implications of your choice, and for you to understand all of the steps of reasoning that you have to go through, if you want to use it to draw conclusions about other programming languages.  Arguably your choice makes some parts of the reasoning easier, and some parts (the application to other programming languages) harder.