[3.15] Detect PEP 810 lazy imports

Author: netromdk

README.rst

@@ -154,9 +154,10 @@ generalized unpacking, ellipsis literal (``...``) out of slices, dictionary unio
 (``list[str]``), function decorators, class decorators, relaxed decorators, ``metaclass`` class
 keyword, pattern matching with ``match``, union types written as ``X | Y``, type alias statements
 (``type X = SomeType``), type alias statements with lambdas/comprehensions in class scopes, generic
-classes (``class C[T]: ...``), and template string literals (``t'{var}'``). It tries to detect and
-ignore user-defined functions, classes, arguments, and variables with names that clash with
-library-defined symbols.
+classes (``class C[T]: ...``), template string literals (``t'{var}'``), lazy imports (``lazy
+import``, ``lazy from ... import``), and special module attributes like ``__lazy_modules__``. It
+tries to detect and ignore user-defined functions, classes, arguments, and variables with names that
+clash with library-defined symbols.
 
 Caveats
 =======

tests/lang.py

@@ -1186,6 +1186,26 @@ def test_unpacking_in_comprehension(self):
     visitor = self.visit("[x for x in range(10)]")
     self.assertFalse(visitor.unpacking_in_comprehension())
 
+  @VerminTest.skipUnlessVersion(3, 15)
+  def test_lazy_imports(self):
+    visitor = self.visit("lazy import foo")
+    self.assertTrue(visitor.lazy_imports())
+    self.assertOnlyIn((3, 15), visitor.minimum_versions())
+
+    visitor = self.visit("lazy from bar import foo")
+    self.assertTrue(visitor.lazy_imports())
+    self.assertOnlyIn((3, 15), visitor.minimum_versions())
+
+    visitor = self.visit("import foo")
+    self.assertFalse(visitor.lazy_imports())
+
+  def test_lazy_modules(self):
+    visitor = self.visit("__lazy_modules__ = {}")
+    self.assertTrue(visitor.lazy_modules())
+    self.assertOnlyIn((3, 15), visitor.minimum_versions())
+
+    visitor = self.visit("__all__ = []")
+    self.assertFalse(visitor.lazy_modules())
   @VerminTest.skipUnlessVersion(3, 5)
   def test_bytes_format(self):
     visitor = self.visit("b'%x' % 10")

vermin/source_state.py

@@ -133,6 +133,11 @@ def __init__(self, config, path=None, source=None):
     # `*x` unpacking in comprehension value expressions (PEP 798).
     self.unpacking_in_comprehension = False
 
+    # `lazy import` statement (PEP 810).
+    self.lazy_imports = False
+
+    # `__lazy_modules__` module attribute.
+    self.lazy_modules = False
     # Imported members of modules, like "exc_clear" of "sys".
     self.import_mem_mod = {}
 

vermin/source_visitor.py

@@ -279,6 +279,12 @@ def generic_class(self):
   def unpacking_in_comprehension(self):
     return self.__s.unpacking_in_comprehension
 
+  def lazy_imports(self):
+    return self.__s.lazy_imports
+
+  def lazy_modules(self):
+    return self.__s.lazy_modules
+
   def __get_source_line(self, line, col=0):
     if self.__s.source is None:
       return None  # pragma: no cover
@@ -535,6 +541,15 @@ def minimum_versions(self):
     if self.unpacking_in_comprehension():
       mins = self.__add_versions_entity(mins, (None, (3, 15)),
                                         "unpacking in comprehension (PEP 798)")
+
+    if self.lazy_imports():
+      mins = self.__add_versions_entity(mins, (None, (3, 15)),
+                                        "lazy imports (PEP 810)")
+
+    if self.lazy_modules():
+      mins = self.__add_versions_entity(mins, (None, (3, 15)),
+                                        "`__lazy_modules__`")
+
     for directive in self.strftime_directives():
       if directive in STRFTIME_REQS:
         vers = STRFTIME_REQS[directive]
@@ -1021,6 +1036,12 @@ def visit_Import(self, node):
     if self.__is_no_line(node.lineno):
       return
 
+    # PEP 810: `lazy import` (3.15+).
+    if hasattr(node, "is_lazy") and node.is_lazy:
+      self.__s.lazy_imports = True
+      self.__vvprint("lazy imports (PEP 810)", line=node.lineno,
+                     versions=[None, (3, 15)])
+
     for name in node.names:
       line = node.lineno
       col = node.col_offset + 7  # "import" = 6 + 1
@@ -1042,6 +1063,12 @@ def visit_ImportFrom(self, node):
     if self.__is_no_line(node.lineno):
       return
 
+    # PEP 810: `lazy from ... import` (3.15+).
+    if hasattr(node, "is_lazy") and node.is_lazy:
+      self.__s.lazy_imports = True
+      self.__vvprint("lazy imports (PEP 810)", line=node.lineno,
+                     versions=[None, (3, 15)])
+
     from_col = 5  # "from" = 4 + 1
     self.__add_module(node.module, node.lineno, node.col_offset + from_col)
 
@@ -1075,6 +1102,10 @@ def visit_Name(self, node):
     elif node.id in ("True", "False"):
       self.__s.bool_const = True
       self.__vvvprint("True/False constant", versions=[(2, 3), (3, 0)])
+    elif node.id == "__lazy_modules__":
+      self.__s.lazy_modules = True
+      self.__vvprint("`__lazy_modules__`", line=node.lineno,
+                     versions=[None, (3, 15)])
 
   def visit_Print(self, node):  # pragma: no cover
     self.__s.printv2 = True