Reflow and reformat to stick to PEP 7's line length limit in most places,

and prefer using `//` for comments instead of `/* */`.

Author: Yhg1s

Doc/library/sys.rst

@@ -916,9 +916,11 @@ always available. Unless explicitly noted otherwise, all variables are read-only
 
    Returns the current lazy imports mode as a string.
 
-   * ``"normal"``: Only imports explicitly marked with the ``lazy`` keyword are lazy
+   * ``"normal"``: Only imports explicitly marked with the ``lazy`` keyword
+     are lazy
    * ``"all"``: All top-level imports are potentially lazy
-   * ``"none"``: All lazy imports are suppressed (even explicitly marked ones)
+   * ``"none"``: All lazy imports are suppressed (even explicitly marked
+     ones)
 
    See also :func:`set_lazy_imports` and :pep:`810`.
 
@@ -927,23 +929,25 @@ always available. Unless explicitly noted otherwise, all variables are read-only
 
 .. function:: get_lazy_imports_filter()
 
-   Returns the current lazy imports filter function, or ``None`` if no filter
-   is set.
+   Returns the current lazy imports filter function, or ``None`` if no
+   filter is set.
 
-   The filter function is called for every potentially lazy import to determine
-   whether it should actually be lazy. See :func:`set_lazy_imports_filter` for
-   details on the filter function signature.
+   The filter function is called for every potentially lazy import to
+   determine whether it should actually be lazy. See
+   :func:`set_lazy_imports_filter` for details on the filter function
+   signature.
 
    .. versionadded:: next
 
 
 .. function:: get_lazy_modules()
 
-   Returns a set of fully-qualified module names that have been lazily imported.
-   This is primarily useful for diagnostics and introspection.
+   Returns a set of fully-qualified module names that have been
+   lazilyimported. This is primarily useful for diagnostics and
+   introspection.
 
-   Note that modules are removed from this set when they are reified (actually
-   loaded on first use).
+   Note that modules are removed from this set when they are reified
+   (actually loaded on first use).
 
    .. versionadded:: next
 
@@ -1759,16 +1763,19 @@ always available. Unless explicitly noted otherwise, all variables are read-only
 
 .. function:: set_lazy_imports(mode)
 
-   Sets the global lazy imports mode. The *mode* parameter must be one of the
-   following strings:
+   Sets the global lazy imports mode. The *mode* parameter must be one of
+   the following strings:
 
-   * ``"normal"``: Only imports explicitly marked with the ``lazy`` keyword are lazy
+   * ``"normal"``: Only imports explicitly marked with the ``lazy`` keyword
+     are lazy
    * ``"all"``: All top-level imports become potentially lazy
-   * ``"none"``: All lazy imports are suppressed (even explicitly marked ones)
+   * ``"none"``: All lazy imports are suppressed (even explicitly marked
+     ones)
 
-   This function is intended for advanced users who need to control lazy imports
-   across their entire application. Library developers should generally not use
-   this function as it affects the runtime execution of applications.
+   This function is intended for advanced users who need to control lazy
+   imports across their entire application. Library developers should
+   generally not use this function as it affects the runtime execution of
+   applications.
 
    In addition to the mode, lazy imports can be controlled via the filter
    provided by :func:`set_lazy_imports_filter`.
@@ -1783,8 +1790,9 @@ always available. Unless explicitly noted otherwise, all variables are read-only
    Sets the lazy imports filter callback. The *filter* parameter must be a
    callable or ``None`` to clear the filter.
 
-   The filter function is called for every potentially lazy import to determine
-   whether it should actually be lazy. It must have the following signature::
+   The filter function is called for every potentially lazy import to
+   determine whether it should actually be lazy. It must have the following
+   signature::
 
       def filter(importing_module: str, imported_module: str,
                  fromlist: tuple[str, ...] | None) -> bool

Doc/whatsnew/3.15.rst

@@ -86,29 +86,31 @@ New features
 :pep:`810`: Explicit lazy imports
 ---------------------------------
 
-Large Python applications often suffer from slow startup times. A significant
-contributor to this problem is the import system: when a module is imported,
-Python must locate the file, read it from disk, compile it to bytecode, and
-execute all top-level code. For applications with deep dependency trees, this
-process can take seconds, even when most of the imported code is never actually
-used during a particular run.
+Large Python applications often suffer from slow startup times. A
+significant contributor to this problem is the import system: when a module
+is imported, Python must locate the file, read it from disk, compile it to
+bytecode, and execute all top-level code. For applications with deep
+dependency trees, this process can take seconds, even when most of the
+imported code is never actually used during a particular run.
 
 Developers have worked around this by moving imports inside functions, using
 :mod:`importlib` to load modules on demand, or restructuring code to avoid
 unnecessary dependencies. These approaches work but make code harder to read
 and maintain, scatter import statements throughout the codebase, and require
 discipline to apply consistently.
 
-Python now provides a cleaner solution through explicit :keyword:`lazy` imports
-using the new ``lazy`` soft keyword. When you mark an import as lazy, Python
-defers the actual module loading until the imported name is first used. This
-gives you the organizational benefits of declaring all imports at the top of
-the file while only paying the loading cost for modules you actually use.
+Python now provides a cleaner solution through explicit :keyword:`lazy`
+imports using the new ``lazy`` soft keyword. When you mark an import as
+lazy, Python defers the actual module loading until the imported name is
+first used. This gives you the organizational benefits of declaring all
+imports at the top of the file while only paying the loading cost for
+modules you actually use.
 
-The ``lazy`` keyword works with both ``import`` and ``from ... import`` statements.
-When you write ``lazy import heavy_module``, Python does not immediately load the
-module. Instead, it creates a lightweight proxy object. The actual module loading
-happens transparently when you first access the name:
+The ``lazy`` keyword works with both ``import`` and ``from ... import``
+statements. When you write ``lazy import heavy_module``, Python does not
+immediately load the module. Instead, it creates a lightweight proxy object.
+The actual module loading happens transparently when you first access the
+name:
 
 .. code-block:: python
 
@@ -120,54 +122,59 @@ happens transparently when you first access the name:
    data = json.loads('{"key": "value"}')  # json gets loads here
    now = datetime()  # datetime loads here
 
-This mechanism is particularly useful for applications that import many modules
-at the top level but may only use a subset of them in any given run. The deferred
-loading reduces startup latency without requiring code restructuring or conditional
-imports scattered throughout the codebase.
-
-In the case where loading a lazily imported module fails (for example, if the
-module does not exist), Python raises the exception at the point of first use
-rather than at import time. The associated traceback includes both the location
-where the name was accessed and the original import statement, making it
-straightforward to diagnose & debug the failure.
-
-For cases where you want to enable lazy loading globally without modifying source
-code, Python provides the :option:`-X lazy_imports <-X>` command-line option and
-the :envvar:`PYTHON_LAZY_IMPORTS` environment variable. Both accept three values:
-``all`` makes all imports lazy by default, ``none`` disables lazy imports entirely
-(even explicit ``lazy`` statements become eager), and ``normal`` (the default)
-respects the ``lazy`` keyword in source code. The :func:`sys.set_lazy_imports` and
-:func:`sys.get_lazy_imports` functions allow changing and querying this mode at
-runtime.
-
-For more selective control, :func:`sys.set_lazy_imports_filter` accepts a callable
-that determines whether a specific module should be loaded lazily. The filter
-receives three arguments: the importing module's name (or ``None``), the imported
-module's name, and the fromlist (or ``None`` for regular imports). It should
-return ``True`` to allow the import to be lazy, or ``False`` to force eager loading.
-This allows patterns like making only your own application's modules lazy while
-keeping third-party dependencies eager:
+This mechanism is particularly useful for applications that import many
+modules at the top level but may only use a subset of them in any given run.
+The deferred loading reduces startup latency without requiring code
+restructuring or conditional imports scattered throughout the codebase.
+
+In the case where loading a lazily imported module fails (for example, if
+the module does not exist), Python raises the exception at the point of
+first use rather than at import time. The associated traceback includes both
+the location where the name was accessed and the original import statement,
+making it straightforward to diagnose & debug the failure.
+
+For cases where you want to enable lazy loading globally without modifying
+source code, Python provides the :option:`-X lazy_imports <-X>` command-line
+option and the :envvar:`PYTHON_LAZY_IMPORTS` environment variable. Both
+accept three values: ``all`` makes all imports lazy by default, ``none``
+disables lazy imports entirely (even explicit ``lazy`` statements become
+eager), and ``normal`` (the default) respects the ``lazy`` keyword in source
+code. The :func:`sys.set_lazy_imports` and :func:`sys.get_lazy_imports`
+functions allow changing and querying this mode at runtime.
+
+For more selective control, :func:`sys.set_lazy_imports_filter` accepts a
+callable that determines whether a specific module should be loaded lazily.
+The filter receives three arguments: the importing module's name (or
+``None``), the imported module's name, and the fromlist (or ``None`` for
+regular imports). It should return ``True`` to allow the import to be lazy,
+or ``False`` to force eager loading. This allows patterns like making only
+your own application's modules lazy while keeping third-party dependencies
+eager:
 
 .. code-block:: python
 
    import sys
 
-   sys.set_lazy_imports_filter(lambda importing, imported, fromlist: imported.startswith("myapp."))
+   def myapp_filter(importing, imported, fromlist):
+       return imported.startswith("myapp.")
+   sys.set_lazy_imports_filter(myapp_filter)
    sys.set_lazy_imports("all")
 
    import myapp.slow_module  # lazy (matches filter)
    import json               # eager (does not match filter)
 
 For debugging and introspection, :func:`sys.get_lazy_modules` returns a set
-containing the names of all modules that have been lazily imported but not yet
-loaded. The proxy type itself is available as :data:`types.LazyImportType` for
-code that needs to detect lazy imports programmatically.
+containing the names of all modules that have been lazily imported but not
+yet loaded. The proxy type itself is available as
+:data:`types.LazyImportType` for code that needs to detect lazy imports
+programmatically.
 
 There are some restrictions on where the ``lazy`` keyword can be used. Lazy
-imports are only permitted at module scope; using ``lazy`` inside a function,
-class body, or ``try``/``except``/``finally`` block raises a :exc:`SyntaxError`.
-Neither star imports nor future imports can be lazy (``lazy from module import *``
-and ``lazy from __future__ import ...`` both raise :exc:`SyntaxError`).
+imports are only permitted at module scope; using ``lazy`` inside a
+function, class body, or ``try``/``except``/``finally`` block raises a
+:exc:`SyntaxError`. Neither star imports nor future imports can be lazy
+(``lazy from module import *`` and ``lazy from __future__ import ...`` both
+raise :exc:`SyntaxError`).
 
 .. seealso:: :pep:`810` for the full specification and rationale.
 

Include/internal/pycore_ceval.h

@@ -311,14 +311,19 @@ PyAPI_FUNC(void) _PyEval_FormatExcCheckArg(PyThreadState *tstate, PyObject *exc,
 PyAPI_FUNC(void) _PyEval_FormatExcUnbound(PyThreadState *tstate, PyCodeObject *co, int oparg);
 PyAPI_FUNC(void) _PyEval_FormatKwargsError(PyThreadState *tstate, PyObject *func, PyObject *kwargs);
 PyAPI_FUNC(PyObject *) _PyEval_ImportFrom(PyThreadState *, PyObject *, PyObject *);
-PyAPI_FUNC(PyObject *) _PyEval_LazyImportName(PyThreadState *tstate, PyObject *builtins, PyObject *globals,
-            PyObject *locals, PyObject *name, PyObject *fromlist, PyObject *level, int lazy);
-PyAPI_FUNC(PyObject *) _PyEval_LazyImportFrom(PyThreadState *tstate, PyObject *v, PyObject *name);
-PyAPI_FUNC(PyObject *) _PyEval_ImportName(PyThreadState *tstate, PyObject *builtins, PyObject *globals, PyObject *locals,
-            PyObject *name, PyObject *fromlist, PyObject *level);
-PyObject *
-_PyEval_ImportNameWithImport(PyThreadState *tstate, PyObject *import_func, PyObject *globals, PyObject *locals,
-                             PyObject *name, PyObject *fromlist, PyObject *level);
+
+PyAPI_FUNC(PyObject *) _PyEval_LazyImportName(
+    PyThreadState *tstate, PyObject *builtins, PyObject *globals,
+    PyObject *locals, PyObject *name, PyObject *fromlist, PyObject *level,
+    int lazy);
+PyAPI_FUNC(PyObject *) _PyEval_LazyImportFrom(
+    PyThreadState *tstate, PyObject *v, PyObject *name);
+PyAPI_FUNC(PyObject *) _PyEval_ImportName(
+    PyThreadState *tstate, PyObject *builtins, PyObject *globals,
+    PyObject *locals, PyObject *name, PyObject *fromlist, PyObject *level);
+PyObject * _PyEval_ImportNameWithImport(
+    PyThreadState *tstate, PyObject *import_func, PyObject *globals,
+    PyObject *locals, PyObject *name, PyObject *fromlist, PyObject *level);
 PyAPI_FUNC(PyObject *)_PyEval_MatchClass(PyThreadState *tstate, PyObject *subject, PyObject *type, Py_ssize_t nargs, PyObject *kwargs);
 PyAPI_FUNC(PyObject *)_PyEval_MatchKeys(PyThreadState *tstate, PyObject *map, PyObject *keys);
 PyAPI_FUNC(void) _PyEval_MonitorRaise(PyThreadState *tstate, _PyInterpreterFrame *frame, _Py_CODEUNIT *instr);

Include/internal/pycore_dict.h

@@ -40,7 +40,8 @@ extern int _PyDict_Contains_KnownHash(PyObject *, PyObject *, Py_hash_t);
 extern PyObject* _PyDict_GetItemIdWithError(PyObject *dp,
                                             _Py_Identifier *key);
 extern int _PyDict_ContainsId(PyObject *, _Py_Identifier *);
-extern int _PyDict_SetItemId(PyObject *dp, _Py_Identifier *key, PyObject *item);
+extern int _PyDict_SetItemId(PyObject *dp, _Py_Identifier *key,
+                             PyObject *item);
 extern int _PyDict_DelItemId(PyObject *mp, _Py_Identifier *key);
 extern void _PyDict_ClearKeysVersion(PyObject *mp);
 

Include/internal/pycore_import.h

@@ -32,17 +32,16 @@ extern int _PyImport_FixupBuiltin(
     PyObject *modules
     );
 
-extern PyObject *
-_PyImport_ResolveName(PyThreadState *tstate, PyObject *name, PyObject *globals, int level);
-extern PyObject *
-_PyImport_GetAbsName(PyThreadState *tstate, PyObject *name, PyObject *globals, int level);
+extern PyObject * _PyImport_ResolveName(
+    PyThreadState *tstate, PyObject *name, PyObject *globals, int level);
+extern PyObject * _PyImport_GetAbsName(
+    PyThreadState *tstate, PyObject *name, PyObject *globals, int level);
 // Symbol is exported for the JIT on Windows builds.
-PyAPI_FUNC(PyObject *)
-_PyImport_LoadLazyImportTstate(PyThreadState *tstate, PyObject *lazy_import);
-extern PyObject *
-_PyImport_LazyImportModuleLevelObject(PyThreadState *tstate, PyObject *name, PyObject *builtins, PyObject *globals,
-                                      PyObject *locals, PyObject *fromlist,
-                                      int level);
+PyAPI_FUNC(PyObject *) _PyImport_LoadLazyImportTstate(
+    PyThreadState *tstate, PyObject *lazy_import);
+extern PyObject * _PyImport_LazyImportModuleLevelObject(
+    PyThreadState *tstate, PyObject *name, PyObject *builtins,
+    PyObject *globals, PyObject *locals, PyObject *fromlist, int level);
 
 
 #ifdef HAVE_DLOPEN
@@ -82,7 +81,8 @@ extern void _PyImport_ClearModules(PyInterpreterState *interp);
 
 extern void _PyImport_ClearModulesByIndex(PyInterpreterState *interp);
 
-extern PyObject * _PyImport_InitLazyModules(PyInterpreterState *interp);
+extern PyObject * _PyImport_InitLazyModules(
+    PyInterpreterState *interp);
 extern void _PyImport_ClearLazyModules(PyInterpreterState *interp);
 
 extern int _PyImport_InitDefaultImportFunc(PyInterpreterState *interp);

Include/internal/pycore_lazyimportobject.h

@@ -1,6 +1,4 @@
-/* File added for Lazy Imports */
-
-/* Lazy object interface */
+// Lazy object interface.
 
 #ifndef Py_INTERNAL_LAZYIMPORTOBJECT_H
 #define Py_INTERNAL_LAZYIMPORTOBJECT_H
@@ -21,16 +19,17 @@ typedef struct {
     PyObject *lz_builtins;
     PyObject *lz_from;
     PyObject *lz_attr;
-    /* Frame information for the original import location */
-    PyCodeObject *lz_code;     /* code object where the lazy import was created */
-    int lz_instr_offset;       /* instruction offset where the lazy import was created */
+    // Frame information for the original import location.
+    PyCodeObject *lz_code;     // Code object where the lazy import was created.
+    int lz_instr_offset;       // Instruction offset where the lazy import was created.
 } PyLazyImportObject;
 
 
 PyAPI_FUNC(PyObject *) _PyLazyImport_GetName(PyObject *lazy_import);
-PyAPI_FUNC(PyObject *) _PyLazyImport_New(PyObject *import_func, PyObject *from, PyObject *attr);
+PyAPI_FUNC(PyObject *) _PyLazyImport_New(
+    PyObject *import_func, PyObject *from, PyObject *attr);
 
 #ifdef __cplusplus
 }
 #endif
-#endif /* !Py_INTERNAL_LAZYIMPORTOBJECT_H */
+#endif // !Py_INTERNAL_LAZYIMPORTOBJECT_H

Include/internal/pycore_moduleobject.h

@@ -78,7 +78,8 @@ extern Py_ssize_t _PyModule_GetFilenameUTF8(
 PyObject* _Py_module_getattro_impl(PyModuleObject *m, PyObject *name, int suppress);
 PyObject* _Py_module_getattro(PyObject *m, PyObject *name);
 
-PyAPI_FUNC(int) _PyModule_ReplaceLazyValue(PyObject *dict, PyObject *name, PyObject *value);
+PyAPI_FUNC(int) _PyModule_ReplaceLazyValue(
+    PyObject *dict, PyObject *name, PyObject *value);
 
 #ifdef __cplusplus
 }

Lib/dis.py

@@ -1019,7 +1019,8 @@ def _find_imports(co):
                 (level_op[0] in hasconst or level_op[0] == LOAD_SMALL_INT)):
                 level = _get_const_value(level_op[0], level_op[1], consts)
                 fromlist = _get_const_value(from_op[0], from_op[1], consts)
-                # IMPORT_NAME encodes lazy/eager flags in bits 0-1, name index in bits 2+
+                # IMPORT_NAME encodes lazy/eager flags in bits 0-1,
+                # name index in bits 2+.
                 yield (names[oparg >> 2], level, fromlist)
 
 def _find_store_names(co):

Lib/idlelib/idle_test/test_colorizer.py

@@ -545,9 +545,11 @@ def test_case_soft_keyword(self):
     def test_lazy_soft_keyword(self):
         # lazy followed by import
         self._assert_highlighting('lazy import foo',
-                                  {'KEYWORD': [('1.0', '1.4'), ('1.5', '1.11')]})
+                                  {'KEYWORD': [('1.0', '1.4'),
+                                               ('1.5', '1.11')]})
         self._assert_highlighting('    lazy import foo',
-                                  {'KEYWORD': [('1.4', '1.8'), ('1.9', '1.15')]})
+                                  {'KEYWORD': [('1.4', '1.8'),
+                                               ('1.9', '1.15')]})
 
         # lazy followed by from
         self._assert_highlighting('lazy from foo import bar',

Lib/rlcompleter.py

@@ -192,7 +192,8 @@ def attr_matches(self, text):
 
                     if (isinstance(thisobject, types.ModuleType)
                         and
-                        isinstance(thisobject.__dict__.get(word), types.LazyImportType)
+                        isinstance(thisobject.__dict__.get(word),
+                                   types.LazyImportType)
                     ):
                         value = thisobject.__dict__.get(word)
                     else: