[issue47224] The variable __module__ in the class body getting an undesirable value from __prepare__ of the metaclass

[Ethan Furman]

Ethan Furman  added the comment:

Stop creating new issues for the same problem.

If you didn't specify the first issue well enough, add your specifics to it and 
continue that conversation.  Splitting the thoughts and feedback across 
multiple issues is not efficient.

Closing this issue, reopening the original (issue47136).

--
nosy: +ethan.furman
resolution:  -> duplicate
stage:  -> resolved
status: open -> closed

___
Python tracker 

___
___
Python-bugs-list mailing list
Unsubscribe: 
https://mail.python.org/mailman/options/python-bugs-list/archive%40mail-archive.com

[issue47224] The variable __module__ in the class body getting an undesirable value from __prepare__ of the metaclass

[Takuo Matsuoka]

New submission from Takuo Matsuoka :

Context
---
Some classes have the variable __name__ in their namespace __dict__ ,
and one may wish to create more such classes with varied values of
__name__ .  Some of those could be created with a metaclass whose
__prepare__ returns a mapping having key "__name__", for which the
value is created depending on the arguments of __prepare__ and can be
updated or deleted in the body of the class to be created.  (See C
below for a very silly example of such a metaclass.)


Problem
---
The value of __name__ given by __prepare__ becomes not just that in
the class body, but automatically also the value of __module__
there.  As far as I could see, this is not documented, and the
programmer might not notice __module__ was messed up.  I think this
behaviour is unexpected and problematic at least unless a warning is
given on it in the document.


Example
---
Here's a code which produces a problem.

```
# In this example, the metaclass C is intended to be a class of
# subclasses of:
B = type

class C(type(B)):
@classmethod
def __prepare__(cls, /, *args, **kwargs):
return dict(__name__ = cls._name(*args, **kwargs))
@classmethod
def _name(cls, /, *args, **kwargs):
# The actual value of __name__ doesn't matter much to the
# issue, so I make this function always return the same silly
# thing in this example.
return type.__dict__["__name__"]

class O(B, metaclass=C):
print(__module__ == __name__) # True
# Could update or delete __name__ here.
```

Consequently,

>>> O.__module__



Discussion
--
If the value of __name__ can be read from the scope
outside for the assignment to __module__, then that will erase this
unexpected behaviour and I think it would be a much safer thing to do.


Remarks
---
The issue was previously

https://bugs.python.org/issue47136

which I'm going to close now since I failed to specify the issue
clearly enough there.  Here I've made the issue more specific.

(The issue is same as https://bugs.python.org/issue47223 which I closed
mistaking it with https://bugs.python.org/issue47136)

The issue is different from but seems related to

https://bugs.python.org/issue28869

I haven't figured out the exact relation.


Thanks.

--
components: Interpreter Core
messages: 416741
nosy: Takuo Matsuoka
priority: normal
severity: normal
status: open
title: The variable __module__ in the class body getting an undesirable value 
from __prepare__ of the metaclass
type: behavior
versions: Python 3.9

___
Python tracker 

___
___
Python-bugs-list mailing list
Unsubscribe: 
https://mail.python.org/mailman/options/python-bugs-list/archive%40mail-archive.com