pyflyby 1.9.7__tar.gz → 1.9.9__tar.gz

{pyflyby-1.9.7/lib/python/pyflyby.egg-info → pyflyby-1.9.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflyby
-Version: 1.9.7
+Version: 1.9.9
 Summary: pyflyby - Python development productivity tools, in particular automatic import management
 Home-page: https://pypi.org/project/pyflyby/
 Author: Karl Chen
@@ -16,7 +16,7 @@ Classifier: Topic :: Software Development :: Interpreters
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Requires-Python: >3.8, <4
+Requires-Python: >3.9, <4
 License-File: LICENSE.txt
 
 #########
@@ -113,7 +113,7 @@ configuration file:
 
 .. code:: python
 
-   
+
     from pyflyby import add_import
 
     add_import("foo", "foo = 1")
@@ -484,29 +484,29 @@ Emacs support
 saveframe: A utility for debugging / reproducing an issue
 =========================================================
 
-PyFlyBy provides a utility named **saveframe** which can be used to save 
+PyFlyBy provides a utility named **saveframe** which can be used to save
 information for debugging / reproducing an issue.
 
-**Usage**: If you have a piece of code or a script that is failing due an issue 
-originating from upstream code, and you cannot share your private code as a reproducer, 
-use this utility to save relevant information to a file. Share the generated file with 
+**Usage**: If you have a piece of code or a script that is failing due an issue
+originating from upstream code, and you cannot share your private code as a reproducer,
+use this utility to save relevant information to a file. Share the generated file with
 the upstream team, enabling them to reproduce and diagnose the issue independently.
 
-**Information saved in the file**: This utility captures and saves *error stack frames* 
-to a file. It includes the values of local variables from each stack frame, as well 
+**Information saved in the file**: This utility captures and saves *error stack frames*
+to a file. It includes the values of local variables from each stack frame, as well
 as metadata about each frame and the exception raised by your code.
 
 This utility comes with 2 interfaces:
 
 1. **A function**: For interactive usages such as IPython, Jupyter Notebook, or a
-   debugger (pdb/ipdb), use **pyflyby.saveframe** function. To know how to use this 
+   debugger (pdb/ipdb), use **pyflyby.saveframe** function. To know how to use this
    function, checkout it's documentation:
 
 .. code::
 
    In [1]: saveframe?
 
-2. **A script**: For cli usages (like a failing script), use **pyflyby/bin/saveframe** 
+2. **A script**: For cli usages (like a failing script), use **pyflyby/bin/saveframe**
    script. To know how to use this script, checkout its documentation:
 
 .. code::

{pyflyby-1.9.7 → pyflyby-1.9.9}/README.rst

@@ -92,7 +92,7 @@ configuration file:
 
 .. code:: python
 
-   
+
     from pyflyby import add_import
 
     add_import("foo", "foo = 1")
@@ -463,29 +463,29 @@ Emacs support
 saveframe: A utility for debugging / reproducing an issue
 =========================================================
 
-PyFlyBy provides a utility named **saveframe** which can be used to save 
+PyFlyBy provides a utility named **saveframe** which can be used to save
 information for debugging / reproducing an issue.
 
-**Usage**: If you have a piece of code or a script that is failing due an issue 
-originating from upstream code, and you cannot share your private code as a reproducer, 
-use this utility to save relevant information to a file. Share the generated file with 
+**Usage**: If you have a piece of code or a script that is failing due an issue
+originating from upstream code, and you cannot share your private code as a reproducer,
+use this utility to save relevant information to a file. Share the generated file with
 the upstream team, enabling them to reproduce and diagnose the issue independently.
 
-**Information saved in the file**: This utility captures and saves *error stack frames* 
-to a file. It includes the values of local variables from each stack frame, as well 
+**Information saved in the file**: This utility captures and saves *error stack frames*
+to a file. It includes the values of local variables from each stack frame, as well
 as metadata about each frame and the exception raised by your code.
 
 This utility comes with 2 interfaces:
 
 1. **A function**: For interactive usages such as IPython, Jupyter Notebook, or a
-   debugger (pdb/ipdb), use **pyflyby.saveframe** function. To know how to use this 
+   debugger (pdb/ipdb), use **pyflyby.saveframe** function. To know how to use this
    function, checkout it's documentation:
 
 .. code::
 
    In [1]: saveframe?
 
-2. **A script**: For cli usages (like a failing script), use **pyflyby/bin/saveframe** 
+2. **A script**: For cli usages (like a failing script), use **pyflyby/bin/saveframe**
    script. To know how to use this script, checkout its documentation:
 
 .. code::

{pyflyby-1.9.7 → pyflyby-1.9.9}/bin/pyflyby/_autoimp.py

@@ -1,9 +1,11 @@
 # pyflyby/_autoimp.py.
-# Copyright (C) 2011, 2012, 2013, 2014, 2015, 2018, 2019 Karl Chen.
+# Copyright (C) 2011, 2012, 2013, 2014, 2015, 2018, 2019, 2024 Karl Chen.
 # License: MIT http://opensource.org/licenses/MIT
 
 
 
+from __future__ import annotations, print_function
+
 import ast
 import builtins
 from   collections.abc          import Sequence
@@ -18,13 +20,14 @@ from   pyflyby._importdb        import ImportDB
 from   pyflyby._importstmt      import Import
 from   pyflyby._log             import logger
 from   pyflyby._modules         import ModuleHandle
-from   pyflyby._parse           import (PythonBlock, _is_ast_str,
-                                        infer_compile_mode, MatchAs)
+from   pyflyby._parse           import (MatchAs, PythonBlock, _is_ast_str,
+                                        infer_compile_mode)
 
 from   six                      import reraise
 import sys
 import types
-from   typing                   import Any, Set
+from   typing                   import (Any, Dict, List, Optional, Set, Tuple,
+                                        Union)
 
 if sys.version_info >= (3, 12):
     ATTRIBUTE_NAME = "value"
@@ -130,9 +133,13 @@ class ScopeStack(Sequence):
     def __len__(self):
         return len(self._tup)
 
-    def with_new_scope(
-        self, include_class_scopes=False, new_class_scope=False, unhide_classdef=False
-    ):
+    def _with_new_scope(
+        self,
+        *,
+        include_class_scopes: bool,
+        new_class_scope: bool,
+        unhide_classdef: bool,
+    ) -> ScopeStack:
         """
         Return a new ``ScopeStack`` with an additional empty scope.
 
@@ -148,8 +155,8 @@ class ScopeStack(Sequence):
         if include_class_scopes:
             scopes = tuple(self)
         else:
-            scopes = tuple(s for s in self
-                           if not isinstance(s, _ClassScope))
+            scopes = tuple(s for s in self if not isinstance(s, _ClassScope))
+        new_scope: Union[_ClassScope, Dict[str, Any]]
         if new_class_scope:
             new_scope = _ClassScope()
         else:
@@ -199,7 +206,7 @@ class ScopeStack(Sequence):
         return (d, self[-1])
 
 
-    def has_star_import(self):
+    def has_star_import(self) -> bool:
         """
         Return whether there are any star-imports in this ScopeStack.
         Only relevant in AST-based static analysis mode.
@@ -341,19 +348,27 @@ def symbol_needs_import(fullname, namespaces):
     return True
 
 
-class _UseChecker(object):
+class _UseChecker:
     """
     An object that can check whether it was used.
     """
-    used = False
 
-    def __init__(self, name, source, lineno):
+    used: bool = False
+    name: str
+    source: str
+    lineno: int
+
+    def __init__(self, name: str, source: str, lineno: int):
         self.name = name
         self.source = source # generally an Import
         self.lineno = lineno
+        logger.debug("Create _UseChecker : %r", self)
+
+    def __repr__(self):
+        return f"<{type(self).__name__}: name:{self.name!r} source:{self.source!r} lineno:{self.lineno} used:{self.used}>"
 
 
-class _MissingImportFinder(object):
+class _MissingImportFinder:
     """
     A helper class to be used only by `_find_missing_imports_in_ast`.
 
@@ -371,8 +386,14 @@ class _MissingImportFinder(object):
 
     """
 
-    def __init__(self, scopestack, find_unused_imports=False,
-                 parse_docstrings=False):
+    scopestack: ScopeStack
+    _lineno: Optional[int]
+    missing_imports: List[Tuple[Optional[int], DottedIdentifier]]
+    parse_docstrings: bool
+    unused_imports: Optional[List[Tuple[int, str]]]
+    _deferred_load_checks: list[tuple[str, ScopeStack, Optional[int]]]
+
+    def __init__(self, scopestack, *, find_unused_imports:bool, parse_docstrings:bool):
         """
         Construct the AST visitor.
 
@@ -384,20 +405,27 @@ class _MissingImportFinder(object):
         # Create a stack of namespaces.  The caller should pass in a list that
         # includes the globals dictionary.  ScopeStack() will make sure this
         # includes builtins.
-        scopestack = ScopeStack(scopestack)
+        _scopestack = ScopeStack(scopestack)
+
         # Add an empty namespace to the stack.  This facilitates adding stuff
         # to scopestack[-1] without ever modifying user globals.
-        scopestack = scopestack.with_new_scope()
-        self.scopestack = scopestack
+        self.scopestack = _scopestack._with_new_scope(
+            include_class_scopes=False, new_class_scope=False, unhide_classdef=False
+        )
+
         # Create data structure to hold the result.
         # missing_imports is a list of (lineno, DottedIdentifier) tuples.
         self.missing_imports = []
+
         # unused_imports is a list of (lineno, Import) tuples, if enabled.
         self.unused_imports = [] if find_unused_imports else None
+
         self.parse_docstrings = parse_docstrings
+
         # Function bodies that we need to check after defining names in this
         # function scope.
         self._deferred_load_checks = []
+
         # Whether we're currently in a FunctionDef.
         self._in_FunctionDef = False
         # Current lineno.
@@ -419,7 +447,8 @@ class _MissingImportFinder(object):
         finally:
             self.scopestack = oldscopestack
 
-    def scan_for_import_issues(self, codeblock):
+    def scan_for_import_issues(self, codeblock: PythonBlock):
+        assert isinstance(codeblock, PythonBlock)
         # See global `scan_for_import_issues`
         if not isinstance(codeblock, PythonBlock):
             codeblock = PythonBlock(codeblock)
@@ -429,6 +458,7 @@ class _MissingImportFinder(object):
         # references in doctests to be noted as missing-imports.  For now we
         # just let the code accumulate into self.missing_imports and ignore
         # the result.
+        logger.debug("unused: %r", self.unused_imports)
         missing_imports = sorted(self.missing_imports)
         if self.parse_docstrings and self.unused_imports is not None:
             doctest_blocks = codeblock.get_doctests()
@@ -446,10 +476,8 @@ class _MissingImportFinder(object):
                 # Currently we don't support the 'global' keyword anyway so
                 # this doesn't matter yet, and it's uncommon to use 'global'
                 # in a doctest, so this is low priority to fix.
-                oldstack = self.scopestack
-                self.scopestack = self.scopestack.with_new_scope()
-                self._scan_node(block.ast_node)
-                self.scopestack = oldstack
+                with self._NewScopeCtx(check_unused_imports=False):
+                    self._scan_node(block.ast_node)
             # Find literal brace identifiers like "... `Foo` ...".
             # TODO: Do this inline: (1) faster; (2) can use proper scope of vars
             # Once we do that, use _check_load() with new args
@@ -532,17 +560,36 @@ class _MissingImportFinder(object):
 
 
     @contextlib.contextmanager
-    def _NewScopeCtx(self, **kwargs):
+    def _NewScopeCtx(
+        self,
+        include_class_scopes=False,
+        new_class_scope=False,
+        unhide_classdef=False,
+        check_unused_imports=True,
+    ):
         """
         Context manager that temporarily pushes a new empty namespace onto the
         stack of namespaces.
         """
         prev_scopestack = self.scopestack
-        new_scopestack = prev_scopestack.with_new_scope(**kwargs)
+        new_scopestack = prev_scopestack._with_new_scope(
+            include_class_scopes=include_class_scopes,
+            new_class_scope=new_class_scope,
+            unhide_classdef=unhide_classdef,
+        )
         self.scopestack = new_scopestack
         try:
             yield
         finally:
+            logger.debug("throwing last scope from scopestack: %r", new_scopestack[-1])
+            for name, use_checker in new_scopestack[-1].items():
+                if use_checker and use_checker.used == False and check_unused_imports:
+                    logger.debug(
+                        "unused checker %r scopestack_depth %r",
+                        use_checker,
+                        len(self.scopestack),
+                    )
+                    self.unused_imports.append((use_checker.lineno, use_checker.source))
             assert self.scopestack is new_scopestack
             self.scopestack = prev_scopestack
 
@@ -588,7 +635,7 @@ class _MissingImportFinder(object):
             return
         if (len(node.targets) == 1 and isinstance(node.targets[0], ast.Name)
             and node.targets[0].id == '__all__'):
-            if not isinstance(node.value, ast.List):
+            if not isinstance(node.value, (ast.List, ast.Tuple)):
                 logger.warning("Don't know how to handle __all__ as (%s)" % node.value)
                 return
             if not all(_is_ast_str(e) for e in node.value.elts):
@@ -672,7 +719,7 @@ class _MissingImportFinder(object):
                 self.visit(node.body)
             self._in_FunctionDef = old_in_FunctionDef
 
-    def _visit_typecomment(self, typecomment):
+    def _visit_typecomment(self, typecomment: str) -> None:
         """
         Warning, when a type comment the node is a string, not an ast node.
         We also get two types of type comments:
@@ -695,6 +742,7 @@ class _MissingImportFinder(object):
         """
         if typecomment is None:
             return
+        node: Union[ast.Module, ast.FunctionType]
         if '->' in typecomment:
             node = ast.parse(typecomment, mode='func_type')
         else:
@@ -702,7 +750,7 @@ class _MissingImportFinder(object):
 
         self.visit(node)
 
-    def visit_arguments(self, node):
+    def visit_arguments(self, node) -> None:
         assert node._fields == ('posonlyargs', 'args', 'vararg', 'kwonlyargs', 'kw_defaults', 'kwarg', 'defaults'), node._fields
         # Argument/parameter list.  Note that the defaults should be
         # considered "Load"s from the upper scope, and the argument names are
@@ -733,7 +781,7 @@ class _MissingImportFinder(object):
         else:
             self._visit_Store(node.kwarg)
 
-    def visit_ExceptHandler(self, node):
+    def visit_ExceptHandler(self, node) -> None:
         assert node._fields == ('type', 'name', 'body')
         if node.type:
             self.visit(node.type)
@@ -909,9 +957,8 @@ class _MissingImportFinder(object):
 
     def _visit_StoreImport(self, node, modulename):
         name = node.asname or node.name
-        logger.debug("_visit_StoreImport(asname=%r,name=%r)",
-                     node.asname, node.name)
-        is_star = node.name == '*'
+        logger.debug("_visit_StoreImport(asname=%r, name=%r)", node.asname, node.name)
+        is_star = node.name == "*"
         if is_star:
             logger.debug("Got star import: line %s: 'from %s import *'",
                          self._lineno, modulename)
@@ -928,7 +975,12 @@ class _MissingImportFinder(object):
             value = _UseChecker(name, imp, self._lineno)
         self._visit_Store(name, value)
 
-    def _visit_Store(self, fullname:str, value=None):
+    def _visit_Store(self, fullname: str, value: Optional[_UseChecker] = None):
+        """
+        Visit a Store action, check for unused import
+        and add current value to the last scope.
+        """
+        assert isinstance(value, (_UseChecker, type(None)))
         logger.debug("_visit_Store(%r)", fullname)
         if fullname is None:
             return
@@ -998,10 +1050,11 @@ class _MissingImportFinder(object):
         # Don't call generic_visit(node) here.  Reason: We already visit the
         # parts above, if relevant.
 
-    def _visit_Load_defered_global(self, fullname):
+    def _visit_Load_defered_global(self, fullname:str):
         """
         Some things will be resolved in global scope later.
         """
+        assert isinstance(fullname, str), fullname
         logger.debug("_visit_Load_defered_global(%r)", fullname)
         if symbol_needs_import(fullname, self.scopestack):
             data = (fullname, self.scopestack, self._lineno)
@@ -1090,7 +1143,11 @@ class _MissingImportFinder(object):
         unused_imports.sort()
 
 
-def scan_for_import_issues(codeblock, find_unused_imports=True, parse_docstrings=False):
+def scan_for_import_issues(
+    codeblock: PythonBlock,
+    find_unused_imports: bool = True,
+    parse_docstrings: bool = False,
+):
     """
     Find missing and unused imports, by lineno.
 
@@ -1117,7 +1174,7 @@ def scan_for_import_issues(codeblock, find_unused_imports=True, parse_docstrings
         ([], [(1, Import('import baz'))])
 
     """
-    logger.debug("scan_for_import_issues()")
+    logger.debug("global scan_for_import_issues()")
     if not isinstance(codeblock, PythonBlock):
         codeblock = PythonBlock(codeblock)
     namespaces = ScopeStack([{}])
@@ -1148,7 +1205,10 @@ def _find_missing_imports_in_ast(node, namespaces):
     # Traverse the abstract syntax tree.
     if logger.debug_enabled:
         logger.debug("ast=%s", ast.dump(node))
-    return _MissingImportFinder(namespaces).find_missing_imports(node)
+    return _MissingImportFinder(
+                 namespaces,
+                 find_unused_imports=False,
+                 parse_docstrings=False).find_missing_imports(node)
 
 # TODO: maybe we should replace _find_missing_imports_in_ast with
 # _find_missing_imports_in_code(compile(node)).  The method of parsing opcodes

{pyflyby-1.9.7 → pyflyby-1.9.9}/bin/pyflyby/_dbg.py

@@ -316,6 +316,14 @@ def _debug_exception(*exc_info, **kwargs):
         # will cause print_verbose_tb to include a line with just a colon.
         # TODO: avoid that line.
         exc_info = ("", "", exc_info)
+    if exc_info[1]:
+        # Explicitly set sys.last_value / sys.last_exc to ensure they are available
+        # in the debugger. One use case is that this allows users to call 
+        # pyflyby.saveframe() within the debugger.
+        if sys.version_info < (3, 12):
+            sys.last_value = exc_info[1]
+        else:
+            sys.last_exc = exc_info[1]
 
     with _DebuggerCtx(tty=tty) as pdb:
         if debugger_attached:

{pyflyby-1.9.7/lib/python → pyflyby-1.9.9/bin}/pyflyby/_dynimp.py

@@ -49,6 +49,7 @@ from pyflyby._importclns import ImportSet, Import
 
 module_dict = {}
 
+PYFLYBY_LAZY_LOAD_PREFIX = "from pyflyby_autoimport_"
 
 def add_import(names: str, code: str, *, strict: bool = True):
     """
@@ -110,8 +111,8 @@ def _add_import(ip, names: str, code: str) -> None:
     private version of add_import
     """
     assert ip is not None
-    mang = "pyflyby_autoimport_" + names.replace(",", "_").replace(" ", "_")
-    a: FrozenSet[Import] = ImportSet(f"from {mang} import {names}")._importset
+    mang = PYFLYBY_LAZY_LOAD_PREFIX + names.replace(",", "_").replace(" ", "_")
+    a: FrozenSet[Import] = ImportSet(f"{mang} import {names}")._importset
     b: FrozenSet[Import] = ip._auto_importer.db.known_imports._importset
     s_import: FrozenSet[Import] = a | b
 

{pyflyby-1.9.7/lib/python → pyflyby-1.9.9/bin}/pyflyby/_importdb.py

@@ -2,6 +2,8 @@
 # Copyright (C) 2011, 2012, 2013, 2014, 2015 Karl Chen.
 # License: MIT http://opensource.org/licenses/MIT
 
+from __future__ import annotations
+
 
 
 from   collections              import defaultdict
@@ -417,7 +419,7 @@ class ImportDB:
         return result
 
     @classmethod
-    def interpret_arg(cls, arg, target_filename):
+    def interpret_arg(cls, arg, target_filename) -> ImportDB:
         if arg is None:
             return cls.get_default(target_filename)
         else:
@@ -560,9 +562,11 @@ class ImportDB:
             filenames = [filenames]
         for f in filenames:
             assert isinstance(f, Filename)
-        logger.debug("ImportDB: loading [%s], mandatory=[%s]",
-                     ', '.join(map(str, filenames)),
-                     ', '.join(map(str, _mandatory_filenames_deprecated)))
+        logger.debug(
+            "ImportDB: loading %r, mandatory=%r",
+            [str(f) for f in filenames],
+            [str(f) for f in _mandatory_filenames_deprecated],
+        )
         if SUPPORT_DEPRECATED_BEHAVIOR:
             # Before 2014-10, pyflyby read the following:
             #   * known_imports from $PYFLYBY_PATH/known_imports/**/*.py or

{pyflyby-1.9.7 → pyflyby-1.9.9}/bin/pyflyby/_imports2s.py

@@ -13,12 +13,12 @@ from   pyflyby._parse           import PythonBlock
 from   pyflyby._util            import ImportPathCtx, Inf, NullCtx, memoize
 import re
 
-from typing import Union
+from typing import Union, Optional, Literal
 
 from textwrap import indent
 
 
-class SourceToSourceTransformationBase(object):
+class SourceToSourceTransformationBase:
 
     input: PythonBlock
 
@@ -121,7 +121,7 @@ class SourceToSourceFileImportsTransformation(SourceToSourceTransformationBase):
         result = [block.pretty_print(params=params) for block in self.blocks]
         return FileText.concatenate(result)
 
-    def find_import_block_by_lineno(self, lineno):
+    def find_import_block_by_lineno(self, lineno: int):
         """
         Find the import block containing the given line number.
 
@@ -312,11 +312,11 @@ def ImportPathForRelativeImportsCtx(codeblock):
 
 
 def fix_unused_and_missing_imports(
-    codeblock: Union[PythonBlock, str],
-    add_missing=True,
-    remove_unused="AUTOMATIC",
-    add_mandatory=True,
-    db=None,
+    codeblock: Union[PythonBlock, str, Filename],
+    add_missing: bool = True,
+    remove_unused: Union[Literal["AUTOMATIC"], bool] = "AUTOMATIC",
+    add_mandatory: bool = True,
+    db: Optional[ImportDB] = None,
     params=None,
 ) -> PythonBlock:
     r"""
@@ -345,6 +345,7 @@ def fix_unused_and_missing_imports(
     :rtype:
       `PythonBlock`
     """
+    _codeblock: PythonBlock
     if isinstance(codeblock, Filename):
         _codeblock = PythonBlock(codeblock)
     if not isinstance(codeblock, PythonBlock):
@@ -393,7 +394,7 @@ def fix_unused_and_missing_imports(
                 logger.error(
                     "%s: couldn't remove import %r", filename, imp,)
             except LineNumberNotFoundError as e:
-                logger.error(
+                logger.debug(
                     "%s: unused import %r on line %d not global",
                     filename, str(imp), e.args[0])
             else:

{pyflyby-1.9.7 → pyflyby-1.9.9}/bin/pyflyby/_importstmt.py

@@ -96,7 +96,7 @@ If <module_name> is ``None``, then there is no "from" clause; instead just::
 """
 
 @total_ordering
-class Import(object):
+class Import:
     """
     Representation of the desire to import a single name into the current
     namespace.