Use type.__fullyqualname__ attribute

Author: vstinner

Lib/_collections_abc.py

@@ -528,9 +528,7 @@ def _type_repr(obj):
     (Keep this roughly in sync with the typing version.)
     """
     if isinstance(obj, type):
-        if obj.__module__ == 'builtins':
-            return obj.__qualname__
-        return f'{obj.__module__}.{obj.__qualname__}'
+        return obj.__fullyqualname__
     if obj is Ellipsis:
         return '...'
     if isinstance(obj, FunctionType):

Lib/_py_abc.py

@@ -71,7 +71,7 @@ def register(cls, subclass):
 
     def _dump_registry(cls, file=None):
         """Debug helper to print the ABC registry."""
-        print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
+        print(f"Class: {cls.__fullyqualname__}", file=file)
         print(f"Inv. counter: {get_cache_token()}", file=file)
         for name in cls.__dict__:
             if name.startswith("_abc_"):

Lib/abc.py

@@ -124,7 +124,7 @@ def __subclasscheck__(cls, subclass):
 
         def _dump_registry(cls, file=None):
             """Debug helper to print the ABC registry."""
-            print(f"Class: {cls.__module__}.{cls.__qualname__}", file=file)
+            print(f"Class: {cls.__fullyqualname__}", file=file)
             print(f"Inv. counter: {get_cache_token()}", file=file)
             (_abc_registry, _abc_cache, _abc_negative_cache,
              _abc_negative_cache_version) = _get_dump(cls)

Lib/codecs.py

@@ -107,8 +107,8 @@ def __new__(cls, encode, decode, streamreader=None, streamwriter=None,
         return self
 
     def __repr__(self):
-        return "<%s.%s object for encoding %s at %#x>" % \
-                (self.__class__.__module__, self.__class__.__qualname__,
+        return "<%s object for encoding %s at %#x>" % \
+                (self.__class__.__fullyqualname__,
                  self.name, id(self))
 
     def __getnewargs__(self):

Lib/contextlib.py

@@ -525,7 +525,7 @@ def enter_context(self, cm):
             _enter = cls.__enter__
             _exit = cls.__exit__
         except AttributeError:
-            raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
+            raise TypeError(f"'{cls.__fullyqualname__}' object does "
                             f"not support the context manager protocol") from None
         result = _enter(cm)
         self._push_cm_exit(cm, _exit)
@@ -662,7 +662,7 @@ async def enter_async_context(self, cm):
             _enter = cls.__aenter__
             _exit = cls.__aexit__
         except AttributeError:
-            raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
+            raise TypeError(f"'{cls.__fullyqualname__}' object does "
                             f"not support the asynchronous context manager protocol"
                            ) from None
         result = await _enter(cm)

Lib/doctest.py

@@ -1401,7 +1401,7 @@ def __run(self, test, compileflags, out):
                     # They start with `SyntaxError:` (or any other class name)
                     exception_line_prefixes = (
                         f"{exception[0].__qualname__}:",
-                        f"{exception[0].__module__}.{exception[0].__qualname__}:",
+                        f"{exception[0].__fullyqualname__}:",
                     )
                     exc_msg_index = next(
                         index

Lib/inspect.py

@@ -1501,9 +1501,9 @@ def repl(match):
     if isinstance(annotation, types.GenericAlias):
         return str(annotation)
     if isinstance(annotation, type):
-        if annotation.__module__ in ('builtins', base_module):
+        if annotation.__module__ == base_module:
             return annotation.__qualname__
-        return annotation.__module__+'.'+annotation.__qualname__
+        return annotation.__fullyqualname__
     return repr(annotation)
 
 def formatannotationrelativeto(object):

Lib/multiprocessing/pool.py

@@ -272,7 +272,7 @@ def __del__(self, _warn=warnings.warn, RUN=RUN):
 
     def __repr__(self):
         cls = self.__class__
-        return (f'<{cls.__module__}.{cls.__qualname__} '
+        return (f'<{cls.__fullyqualname__} '
                 f'state={self._state} '
                 f'pool_size={len(self._pool)}>')
 

Lib/pdb.py

@@ -1726,7 +1726,7 @@ def do_whatis(self, arg):
             return
         # Is it a class?
         if value.__class__ is type:
-            self.message('Class %s.%s' % (value.__module__, value.__qualname__))
+            self.message(f'Class {value.__fullyqualname__}')
             return
         # None of the above...
         self.message(type(value))

Lib/test/support/asyncore.py

@@ -256,7 +256,7 @@ def __init__(self, sock=None, map=None):
             self.socket = None
 
     def __repr__(self):
-        status = [self.__class__.__module__+"."+self.__class__.__qualname__]
+        status = [self.__class__.__fullyqualname__]
         if self.accepting and self.addr:
             status.append('listening')
         elif self.connected:

Lib/test/test_configparser.py

@@ -587,8 +587,7 @@ def get_error(self, cf, exc, section, option):
         except exc as e:
             return e
         else:
-            self.fail("expected exception type %s.%s"
-                      % (exc.__module__, exc.__qualname__))
+            self.fail(f"expected exception type {exc.__fullyqualname__}")
 
     def test_boolean(self):
         cf = self.fromstring(

Lib/test/test_traceback.py

@@ -209,10 +209,10 @@ def __str__(self):
         err = traceback.format_exception_only(X, X())
         self.assertEqual(len(err), 1)
         str_value = '<exception str() failed>'
-        if X.__module__ in ('__main__', 'builtins'):
+        if X.__module__ == '__main__':
             str_name = X.__qualname__
         else:
-            str_name = '.'.join([X.__module__, X.__qualname__])
+            str_name = X.__fullyqualname__
         self.assertEqual(err[0], "%s: %s\n" % (str_name, str_value))
 
     def test_format_exception_group_without_show_group(self):
@@ -1875,7 +1875,7 @@ def __str__(self):
 
         err = self.get_report(A.B.X())
         str_value = 'I am X'
-        str_name = '.'.join([A.B.X.__module__, A.B.X.__qualname__])
+        str_name = A.B.X.__fullyqualname__
         exp = "%s: %s\n" % (str_name, str_value)
         self.assertEqual(exp, MODULE_PREFIX + err)
 
@@ -1889,10 +1889,10 @@ def __str__(self):
             with self.subTest(modulename=modulename):
                 err = self.get_report(X())
                 str_value = 'I am X'
-                if modulename in ['builtins', '__main__']:
+                if modulename ==  '__main__':
                     str_name = X.__qualname__
                 else:
-                    str_name = '.'.join([X.__module__, X.__qualname__])
+                    str_name = X.__fullyqualname__
                 exp = "%s: %s\n" % (str_name, str_value)
                 self.assertEqual(exp, err)
 
@@ -1928,7 +1928,7 @@ def __str__(self):
                 1/0
         err = self.get_report(X())
         str_value = '<exception str() failed>'
-        str_name = '.'.join([X.__module__, X.__qualname__])
+        str_name = X.__fullyqualname__
         self.assertEqual(MODULE_PREFIX + err, f"{str_name}: {str_value}\n")
 
 

Lib/test/test_zipimport_support.py

@@ -39,7 +39,7 @@ def _run_object_doctest(obj, module):
     # Use the object's fully qualified name if it has one
     # Otherwise, use the module's name
     try:
-        name = "%s.%s" % (obj.__module__, obj.__qualname__)
+        name = obj.__fullyqualname__
     except AttributeError:
         name = module.__name__
     for example in finder.find(obj, name, module):

Lib/threading.py

@@ -457,7 +457,7 @@ def __init__(self, value=1):
 
     def __repr__(self):
         cls = self.__class__
-        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+        return (f"<{cls.__fullyqualname__} at {id(self):#x}:"
                 f" value={self._value}>")
 
     def acquire(self, blocking=True, timeout=None):
@@ -547,7 +547,7 @@ def __init__(self, value=1):
 
     def __repr__(self):
         cls = self.__class__
-        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+        return (f"<{cls.__fullyqualname__} at {id(self):#x}:"
                 f" value={self._value}/{self._initial_value}>")
 
     def release(self, n=1):
@@ -587,7 +587,7 @@ def __init__(self):
     def __repr__(self):
         cls = self.__class__
         status = 'set' if self._flag else 'unset'
-        return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: {status}>"
+        return f"<{cls.__fullyqualname__} at {id(self):#x}: {status}>"
 
     def _at_fork_reinit(self):
         # Private method called by Thread._after_fork()
@@ -690,8 +690,8 @@ def __init__(self, parties, action=None, timeout=None):
     def __repr__(self):
         cls = self.__class__
         if self.broken:
-            return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: broken>"
-        return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
+            return f"<{cls.__fullyqualname__} at {id(self):#x}: broken>"
+        return (f"<{cls.__fullyqualname__} at {id(self):#x}:"
                 f" waiters={self.n_waiting}/{self.parties}>")
 
     def wait(self, timeout=None):

Lib/tkinter/__init__.py

@@ -1802,8 +1802,7 @@ def __str__(self):
         return self._w
 
     def __repr__(self):
-        return '<%s.%s object %s>' % (
-            self.__class__.__module__, self.__class__.__qualname__, self._w)
+        return f'<{self.__class__.__fullyqualname__} object {self._w}>'
 
     # Pack methods that apply to the master
     _noarg_ = ['_noarg_']

Lib/tkinter/font.py

@@ -101,8 +101,8 @@ def __str__(self):
         return self.name
 
     def __repr__(self):
-        return f"<{self.__class__.__module__}.{self.__class__.__qualname__}" \
-               f" object {self.name!r}>"
+        return (f"<{self.__class__.__fullyqualname__}"
+                f" object {self.name!r}>")
 
     def __eq__(self, other):
         if not isinstance(other, Font):

Lib/typing.py

@@ -236,9 +236,7 @@ def _type_repr(obj):
     # `_collections_abc._type_repr`, which does the same thing
     # and must be consistent with this one.
     if isinstance(obj, type):
-        if obj.__module__ == 'builtins':
-            return obj.__qualname__
-        return f'{obj.__module__}.{obj.__qualname__}'
+        return obj.__fullyqualname__
     if obj is ...:
         return '...'
     if isinstance(obj, types.FunctionType):
@@ -1402,10 +1400,7 @@ def __init__(self, origin, nparams, *, inst=True, name=None):
             name = origin.__name__
         super().__init__(origin, inst=inst, name=name)
         self._nparams = nparams
-        if origin.__module__ == 'builtins':
-            self.__doc__ = f'A generic version of {origin.__qualname__}.'
-        else:
-            self.__doc__ = f'A generic version of {origin.__module__}.{origin.__qualname__}.'
+        self.__doc__ = f'A generic version of {origin.__fullyqualname__}.'
 
     @_tp_cache
     def __getitem__(self, params):

Lib/unittest/async_case.py

@@ -74,7 +74,7 @@ async def enterAsyncContext(self, cm):
             enter = cls.__aenter__
             exit = cls.__aexit__
         except AttributeError:
-            raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
+            raise TypeError(f"'{cls.__fullyqualname__}' object does "
                             f"not support the asynchronous context manager protocol"
                            ) from None
         result = await enter(cm)

Lib/unittest/case.py

@@ -111,7 +111,7 @@ def _enter_context(cm, addcleanup):
         enter = cls.__enter__
         exit = cls.__exit__
     except AttributeError:
-        raise TypeError(f"'{cls.__module__}.{cls.__qualname__}' object does "
+        raise TypeError(f"'{cls.__fullyqualname__}' object does "
                         f"not support the context manager protocol") from None
     result = enter(cm)
     addcleanup(exit, cm, None, None, None)

Lib/unittest/loader.py

@@ -216,9 +216,7 @@ def shouldIncludeMethod(attrname):
             testFunc = getattr(testCaseClass, attrname)
             if not callable(testFunc):
                 return False
-            fullName = f'%s.%s.%s' % (
-                testCaseClass.__module__, testCaseClass.__qualname__, attrname
-            )
+            fullName = f'{testCaseClass.__fullyqualname__}.{attrname}'
             return self.testNamePatterns is None or \
                 any(fnmatchcase(fullName, pattern) for pattern in self.testNamePatterns)
         testFnNames = list(filter(shouldIncludeMethod, dir(testCaseClass)))

Lib/unittest/util.py

@@ -52,7 +52,7 @@ def safe_repr(obj, short=False):
     return result[:_MAX_LENGTH] + ' [truncated]...'
 
 def strclass(cls):
-    return "%s.%s" % (cls.__module__, cls.__qualname__)
+    return cls.__fullyqualname__
 
 def sorted_list_difference(expected, actual):
     """Finds elements in only one or the other of two, sorted input lists.