Add resolve_name(name, *, strict=False)

The PEP describes this as an open issue, but it's the cleanest approach.

Author: warsaw

Doc/library/pkgutil.rst

@@ -194,7 +194,7 @@ support.
       The :mod:`importlib.resources` module provides structured access to
       module resources.
 
-.. function:: resolve_name(name)
+.. function:: resolve_name(name, *, strict=False)
 
    Resolve a name to an object.
 
@@ -208,6 +208,7 @@ support.
 
    * ``W(.W)*``
    * ``W(.W)*:(W(.W)*)?``
+   * ``W(.W)*:(W(.W)*)``
 
    The first form is intended for backward compatibility only. It assumes that
    some part of the dotted name is a package, and the rest is an object
@@ -222,6 +223,11 @@ support.
    hierarchy within that package. Only one import is needed in this form. If
    it ends with the colon, then a module object is returned.
 
+   The first two forms are accepted when ``strict=False`` (the default).
+
+   The third form requires both the module name and callable, separated by
+   a colon. Only this form is accepted when ``strict=True``.
+
    The function will return an object (which might be a module), or raise one
    of the following exceptions:
 
@@ -233,3 +239,7 @@ support.
    hierarchy within the imported package to get to the desired object.
 
    .. versionadded:: 3.9
+
+   .. versionchanged:: 3.15
+
+      The optional keyword-only ``strict`` flag was added.

Lib/pkgutil.py

@@ -9,6 +9,9 @@
 import os.path
 import sys
 
+lazy import re
+
+
 __all__ = [
     'get_importer', 'iter_importers',
     'walk_packages', 'iter_modules', 'get_data',
@@ -398,9 +401,10 @@ def get_data(package, resource):
     return loader.get_data(resource_name)
 
 
-_NAME_PATTERN = None
+_LENIENT_PATTERN = None
+_STRICT_PATTERN = None
 
-def resolve_name(name):
+def resolve_name(name, *, strict=False):
     """
     Resolve a name to an object.
 
@@ -410,6 +414,7 @@ def resolve_name(name):
 
     W(.W)*
     W(.W)*:(W(.W)*)?
+    W(.W)*:(W(.W)*)
 
     The first form is intended for backward compatibility only. It assumes that
     some part of the dotted name is a package, and the rest is an object
@@ -424,6 +429,11 @@ def resolve_name(name):
     hierarchy within that package. Only one import is needed in this form. If
     it ends with the colon, then a module object is returned.
 
+    The first two forms are accepted when `strict=False` (the default).
+
+    The third form requires both the module name and callable, separated by
+    a colon. Only this form is accepted when `strict=True`.
+
     The function will return an object (which might be a module), or raise one
     of the following exceptions:
 
@@ -432,18 +442,26 @@ def resolve_name(name):
     AttributeError - if a failure occurred when traversing the object hierarchy
                      within the imported package to get to the desired object.
     """
-    global _NAME_PATTERN
-    if _NAME_PATTERN is None:
-        # Lazy import to speedup Python startup time
-        import re
-        dotted_words = r'(?!\d)(\w+)(\.(?!\d)(\w+))*'
-        _NAME_PATTERN = re.compile(f'^(?P<pkg>{dotted_words})'
-                                   f'(?P<cln>:(?P<obj>{dotted_words})?)?$',
-                                   re.UNICODE)
-
-    m = _NAME_PATTERN.match(name)
-    if not m:
+    global _LENIENT_PATTERN, _STRICT_PATTERN
+    dotted_words = r'(?!\d)(\w+)(\.(?!\d)(\w+))*'
+    if strict:
+        if _STRICT_PATTERN is None:
+            _STRICT_PATTERN = re.compile(
+                f'^(?P<pkg>{dotted_words})'
+                f'(?P<cln>:(?P<obj>{dotted_words}))$',
+                re.UNICODE)
+        pattern = _STRICT_PATTERN
+    else:
+        if _LENIENT_PATTERN is None:
+            _LENIENT_PATTERN = re.compile(
+                f'^(?P<pkg>{dotted_words})'
+                f'(?P<cln>:(?P<obj>{dotted_words})?)?$',
+                re.UNICODE)
+        pattern = _LENIENT_PATTERN
+
+    if (m := pattern.match(name)) is None:
         raise ValueError(f'invalid format: {name!r}')
+
     gd = m.groupdict()
     if gd.get('cln'):
         # there is a colon - a one-step import is all that's needed

Lib/test/test_pkgutil.py

@@ -322,6 +322,56 @@ def test_name_resolution(self):
                 with self.assertRaises(exc):
                     pkgutil.resolve_name(s)
 
+    def test_name_resolution_strict(self):
+        # PEP 829: strict=True accepts only the pkg.mod:callable form
+        # (W(.W)*:W(.W)*) -- both the colon and the callable are required.
+        import logging
+        import logging.handlers
+
+        success_cases = (
+            ('os.path:pathsep', os.path.pathsep),
+            ('logging.handlers:SysLogHandler',
+                logging.handlers.SysLogHandler),
+            ('logging.handlers:SysLogHandler.LOG_ALERT',
+                logging.handlers.SysLogHandler.LOG_ALERT),
+            ('builtins:int', int),
+            ('builtins:int.from_bytes', int.from_bytes),
+            ('os:path', os.path),
+        )
+
+        # All of these are accepted under strict=False but must be
+        # rejected under strict=True.
+        failure_cases = (
+            'os',                       # no colon (non-strict form)
+            'os.path',                  # no colon
+            'logging:',                 # colon, empty callable
+            'os.foo:',                  # colon, empty callable
+            ':int',                     # empty package
+            'os.path:join:extra',       # extra colon
+            'os.path.9abc:join',        # invalid identifier in package
+            'os.path:9abc',             # invalid identifier in callable
+            '',                         # empty
+            '?abc:foo',                 # invalid character
+        )
+
+        for s, expected in success_cases:
+            with self.subTest(s=s):
+                self.assertEqual(
+                    pkgutil.resolve_name(s, strict=True), expected)
+
+        for s in failure_cases:
+            with self.subTest(s=s):
+                with self.assertRaises(ValueError):
+                    pkgutil.resolve_name(s, strict=True)
+
+        # Cache independence: a strict=True call must not poison
+        # strict=False (and vice versa).  Exercise both orderings.
+        self.assertEqual(
+            pkgutil.resolve_name('os:path', strict=True), os.path)
+        self.assertEqual(pkgutil.resolve_name('os.path'), os.path)
+        self.assertEqual(
+            pkgutil.resolve_name('os:path', strict=True), os.path)
+
     def test_name_resolution_import_rebinding(self):
         # The same data is also used for testing import in test_import and
         # mock.patch in test_unittest.

Misc/NEWS.d/next/Library/2026-04-15-21-46-52.gh-issue-148641.-aoFyC.rst

@@ -1,3 +1,6 @@
 :pep:`829` (package startup configuration files) implements a new format
 ``<name>.start`` parallel to ``<name>.pth`` files, to replace ``import``
 lines in the latter.
+
+:func:`pkgutil.resolve_name` gets a new optional, keyword-only argument called
+``strict``.  The default is ``False`` for backward compatibility.