Add lru cache for moduleless objects

Author: mdeck

Lib/inspect.py

@@ -155,6 +155,7 @@
 import tokenize
 import token
 import types
+import weakref
 import functools
 import builtins
 from keyword import iskeyword
@@ -918,6 +919,14 @@ def getfile(object):
             if object.__module__ == '__main__':
                 raise OSError('source code not available')
         raise TypeError('{!r} is a built-in class'.format(object))
+    if code := _getcode(object):
+        return code.co_filename
+    raise TypeError('module, class, method, function, traceback, frame, or '
+                    'code object was expected, got {}'.format(
+                    type(object).__name__))
+
+def _getcode(object):
+    """Get the code object an object is associated with, if available."""
     if ismethod(object):
         object = object.__func__
     if isfunction(object):
@@ -927,10 +936,8 @@ def getfile(object):
     if isframe(object):
         object = object.f_code
     if iscode(object):
-        return object.co_filename
-    raise TypeError('module, class, method, function, traceback, frame, or '
-                    'code object was expected, got {}'.format(
-                    type(object).__name__))
+        return object
+    return None
 
 def getmodulename(path):
     """Return the module name for a given file, or None."""
@@ -980,6 +987,22 @@ def getabsfile(object, _filename=None):
 
 modulesbyfile = {}
 _filesbymodname = {}
+_moduleless = OrderedDict()
+_MAX_MODULELESS = 200
+
+def _is_cached_moduleless(code):
+    if ref := _moduleless.get(id(code)):
+        if ref() is code:
+            _moduleless.move_to_end(id(code), last=True)
+            return True
+    return False
+
+def _cache_moduleless(code):
+    if code is None:
+        return
+    _moduleless[id(code)] = weakref.ref(code)
+    if len(_moduleless) > _MAX_MODULELESS:
+        _moduleless.popitem(last=False)
 
 def getmodule(object, _filename=None):
     """Return the module an object was defined in, or None if not found."""
@@ -990,31 +1013,26 @@ def getmodule(object, _filename=None):
     # Try the filename to modulename cache
     if _filename is not None and _filename in modulesbyfile:
         return sys.modules.get(modulesbyfile[_filename])
+    # Check for moduleless objects
+    code = _getcode(object)
+    if _is_cached_moduleless(code):
+        return None
     # Try the cache again with the absolute file name
     try:
         file = getabsfile(object, _filename)
     except (TypeError, FileNotFoundError):
+        _cache_moduleless(code)
         return None
     if file in modulesbyfile:
         return sys.modules.get(modulesbyfile[file])
     # Update the filename to module name cache and check yet again
-    # Copy sys.modules in order to cope with changes while iterating
-    for modname, module in sys.modules.copy().items():
-        if ismodule(module) and hasattr(module, '__file__'):
-            f = module.__file__
-            if f == _filesbymodname.get(modname, None):
-                # Have already mapped this module, so skip it
-                continue
-            _filesbymodname[modname] = f
-            f = getabsfile(module)
-            # Always map to the name the module knows itself by
-            modulesbyfile[f] = modulesbyfile[
-                os.path.realpath(f)] = module.__name__
+    _update_module_filename_cache()
     if file in modulesbyfile:
         return sys.modules.get(modulesbyfile[file])
     # Check the main module
     main = sys.modules['__main__']
     if not hasattr(object, '__name__'):
+        _cache_moduleless(code)
         return None
     if hasattr(main, object.__name__):
         mainobject = getattr(main, object.__name__)
@@ -1026,6 +1044,23 @@ def getmodule(object, _filename=None):
         builtinobject = getattr(builtin, object.__name__)
         if builtinobject is object:
             return builtin
+    _cache_moduleless(code)
+    return None
+
+def _update_module_filename_cache():
+    """Update the filename to module name cache."""
+    # Copy sys.modules in order to cope with changes while iterating
+    for modname, module in sys.modules.copy().items():
+        if ismodule(module) and hasattr(module, '__file__'):
+            f = module.__file__
+            if f == _filesbymodname.get(modname, None):
+                # Have already mapped this module, so skip it
+                continue
+            _filesbymodname[modname] = f
+            f = getabsfile(module)
+            # Always map to the name the module knows itself by
+            modulesbyfile[f] = modulesbyfile[
+                os.path.realpath(f)] = module.__name__
 
 
 class ClassFoundException(Exception):

Lib/test/test_inspect/test_inspect.py

@@ -671,13 +671,35 @@ def test_getmodule(self):
 
     def test_getmodule_file_not_found(self):
         # See bpo-45406
+        checked_objs = set()
         def _getabsfile(obj, _filename):
+            # Ensure non-caching is working
+            self.assertNotIn(obj, checked_objs)
+            checked_objs.add(obj)
             raise FileNotFoundError('bad file')
         with unittest.mock.patch('inspect.getabsfile', _getabsfile):
             f = inspect.currentframe()
             self.assertIsNone(inspect.getmodule(f))
             inspect.getouterframes(f)  # smoke test
 
+    def test_getmodule_cache(self):
+        with unittest.mock.patch(
+            'inspect._update_module_filename_cache',
+            side_effect=inspect._update_module_filename_cache,
+        ) as mock_update, unittest.mock.patch(
+            'inspect.getmodule', side_effect=inspect.getmodule
+        ) as mock_getmodule:
+            d = {}
+            exec("def x(): pass", d)
+            inspect.getmodule(d["x"].__code__)
+            self.assertTrue(mock_update.call_count > 0)
+            mock_getmodule.reset_mock()
+            mock_update.reset_mock()
+            inspect.getmodule(d["x"].__code__)
+            self.assertEqual(mock_getmodule.call_count, 1)
+            self.assertEqual(mock_update.call_count, 0)
+        inspect._moduleless.clear()
+
     def test_getframeinfo_get_first_line(self):
         frame_info = inspect.getframeinfo(self.fodderModule.fr, 50)
         self.assertEqual(frame_info.code_context[0], "# line 1\n")
@@ -750,6 +772,7 @@ def test_getmodule_recursion(self):
         self.assertEqual(inspect.getsourcefile(m.x.__code__), '<string>')
         del sys.modules[name]
         inspect.getmodule(compile('a=10','','single'))
+        inspect._moduleless.clear()
 
     def test_proceed_with_fake_filename(self):
         '''doctest monkeypatches linecache to enable inspection'''
@@ -767,6 +790,7 @@ def monkey(filename, module_globals=None):
             inspect.getsource(ns["x"])
         finally:
             linecache.getlines = getlines
+            inspect._moduleless.clear()
 
     def test_getsource_on_code_object(self):
         self.assertSourceEqual(mod.eggs.__code__, 12, 18)