pyflyby 1.9.8__tar.gz → 1.9.10__tar.gz

{pyflyby-1.9.8/lib/python/pyflyby.egg-info → pyflyby-1.9.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflyby
-Version: 1.9.8
+Version: 1.9.10
 Summary: pyflyby - Python development productivity tools, in particular automatic import management
 Home-page: https://pypi.org/project/pyflyby/
 Author: Karl Chen

{pyflyby-1.9.8 → pyflyby-1.9.10}/bin/pyflyby/_autoimp.py

@@ -4,6 +4,8 @@
 
 
 
+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, Optional, List, Tuple
+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.
@@ -355,9 +362,10 @@ class _UseChecker:
         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} source:{self.source!r} lineno:{self.lineno} used:{self.used}>"
+        return f"<{type(self).__name__}: name:{self.name!r} source:{self.source!r} lineno:{self.lineno} used:{self.used}>"
 
 
 class _MissingImportFinder:
@@ -397,13 +405,13 @@ class _MissingImportFinder:
         # 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.
@@ -450,6 +458,7 @@ class _MissingImportFinder:
         # 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()
@@ -467,10 +476,8 @@ class _MissingImportFinder:
                 # 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
@@ -553,17 +560,36 @@ class _MissingImportFinder:
 
 
     @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
 
@@ -693,7 +719,7 @@ class _MissingImportFinder:
                 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:
@@ -716,6 +742,7 @@ class _MissingImportFinder:
         """
         if typecomment is None:
             return
+        node: Union[ast.Module, ast.FunctionType]
         if '->' in typecomment:
             node = ast.parse(typecomment, mode='func_type')
         else:
@@ -723,7 +750,7 @@ class _MissingImportFinder:
 
         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
@@ -754,7 +781,7 @@ class _MissingImportFinder:
         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)
@@ -948,7 +975,12 @@ class _MissingImportFinder:
             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

{pyflyby-1.9.8 → pyflyby-1.9.10}/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:
@@ -324,7 +332,27 @@ def _debug_exception(*exc_info, **kwargs):
             # keep the process waiting for debugger to attach.
             pdb.postloop = _prompt_continue_waiting_for_debugger
         print_verbose_tb(*exc_info)
-        pdb.interaction(None, exc_info[2])
+        # Starting Py3.13, pdb.interaction() supports chained exceptions in case
+        # exception (and not traceback) is specified. This support is backported
+        # to IPython8.16 for earlier Python versions. So the conditions where
+        # chained exceptions won't be supported from here would be with the
+        # Python version < 3.13 and ipython not installed, or IPython's version
+        # is lesser than 8.16.
+        tb_or_exc = exc_info[2]
+        if sys.version_info < (3, 13):
+            # Check if the instance is of IPython's Pdb and its version.
+            try:
+                import IPython
+                if IPython.version_info >= (8, 16):
+                    from IPython.core.debugger import Pdb as IPdb
+                    # This is expected to be True, hence just a safe check.
+                    if isinstance(pdb, IPdb):
+                        tb_or_exc = exc_info[1]
+            except ModuleNotFoundError:
+                pass
+        else:
+            tb_or_exc = exc_info[1]
+        pdb.interaction(None, tb_or_exc)
 
 
 def _debug_code(arg, globals=None, locals=None, auto_import=True, tty="/dev/tty"):

{pyflyby-1.9.8/lib/python → pyflyby-1.9.10/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,7 +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(" ", "_")
+    module = PYFLYBY_LAZY_LOAD_PREFIX.split()[1]
+    mang = module + names.replace(",", "_").replace(" ", "_")
     a: FrozenSet[Import] = ImportSet(f"from {mang} import {names}")._importset
     b: FrozenSet[Import] = ip._auto_importer.db.known_imports._importset
     s_import: FrozenSet[Import] = a | b

{pyflyby-1.9.8/lib/python → pyflyby-1.9.10/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:

{pyflyby-1.9.8 → pyflyby-1.9.10}/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.8 → pyflyby-1.9.10}/bin/pyflyby/_interactive.py

@@ -22,7 +22,8 @@ from   pyflyby._autoimp         import (LoadSymbolError, ScopeStack, auto_eval,
                                         auto_import,
                                         clear_failed_imports_cache,
                                         load_symbol)
-from   pyflyby._dynimp          import inject as inject_dynamic_import
+from   pyflyby._dynimp          import (inject as inject_dynamic_import, 
+                                        PYFLYBY_LAZY_LOAD_PREFIX)
 from   pyflyby._comms           import (initialize_comms, remove_comms,
                                         send_comm_message, MISSING_IMPORTS)
 from   pyflyby._file            import Filename, atomic_write_file, read_file
@@ -35,7 +36,6 @@ from   pyflyby._util            import (AdviceCtx, Aspect, CwdCtx,
                                         FunctionWithGlobals, NullCtx, advise,
                                         indent)
 
-
 if False:
     __original__ = None # for pyflakes
 
@@ -85,9 +85,6 @@ def _get_or_create_ipython_terminal_app():
         pass
     else:
         return TerminalIPythonApp.instance()
-    # The following has been tested on IPython 0.10.
-    if hasattr(IPython, "ipapi"):
-        return _IPython010TerminalApplication.instance()
     raise RuntimeError(
         "Couldn't get TerminalIPythonApp class.  "
         "Is your IPython version too old (or too new)?  "
@@ -122,51 +119,6 @@ def _app_is_initialized(app):
 
 
 
-class _IPython010TerminalApplication(object):
-    """
-    Shim class that mimics IPython 0.11+ application classes, for use in
-    IPython 0.10.
-    """
-
-    # IPython.ipapi.launch_instance() => IPython.Shell.start() creates an
-    # instance of "IPShell".  IPShell has an attribute named "IP" which is an
-    # "InteractiveShell".
-
-    _instance = None
-
-    @classmethod
-    def instance(cls):
-        if cls._instance is not None:
-            self = cls._instance
-            self.init_shell()
-            return self
-        import IPython
-        if not hasattr(IPython, "ipapi"):
-            raise RuntimeError("Inappropriate version of IPython %r"
-                               % (IPython.__version__,))
-        self = cls._instance = cls()
-        self.init_shell()
-        return self
-
-    def init_shell(self):
-        import IPython
-        ipapi = IPython.ipapi.get()                # IPApi instance
-        if ipapi is not None:
-            self.shell = ipapi.IP                  # InteractiveShell instance
-        else:
-            self.shell = None
-
-    def initialize(self, argv=None):
-        import IPython
-        logger.debug("Creating IPython 0.10 session")
-        self._session = IPython.ipapi.make_session() # IPShell instance
-        self.init_shell()
-        assert self._session is not None
-
-    def start(self):
-        self._session.mainloop()
-
-
 
 class _DummyIPythonEmbeddedApp(object):
     """
@@ -412,30 +364,7 @@ def install_in_ipython_config_file():
     else:
         _install_in_ipython_config_file_40()
         return
-    # The following has been tested on IPython 0.12, 0.13, 1.0, 1.2, 2.0, 2.1,
-    # 2.2, 2.3, 2.4, 3.0, 3.1, 3.2, 4.0.
-    try:
-        IPython.core.profiledir.ProfileDir.startup_dir
-    except AttributeError:
-        pass
-    else:
-        _install_in_ipython_config_file_012()
-        return
-    # The following has been tested on IPython 0.11.
-    try:
-        IPython.core.profiledir.ProfileDir
-    except AttributeError:
-        pass
-    else:
-        _install_in_ipython_config_file_011()
-        return
-    try:
-        IPython.genutils.get_ipython_dir
-    except AttributeError:
-        pass
-    else:
-        _install_in_ipython_config_file_010()
-        return
+
     raise RuntimeError(
         "Couldn't install pyflyby autoimporter in IPython.  "
         "Is your IPython version too old (or too new)?  "
@@ -555,96 +484,10 @@ def _install_in_ipython_config_file_40():
         logger.info("[DONE] Removed old file %s (moved to %s)", old_fn, trash_fn)
 
 
-def _install_in_ipython_config_file_012():
-    """
-    Implementation of `install_in_ipython_config_file` for IPython 0.12+.
-    Tested with IPython 0.12, 0.13, 1.0, 1.2, 2.0, 2.1, 2.2, 2.3, 2.4, 3.0,
-    3.1, 3.2, 4.0.
-    """
-    import IPython
-    ipython_dir = Filename(IPython.utils.path.get_ipython_dir())
-    if not ipython_dir.isdir:
-        raise RuntimeError(
-            "Couldn't find IPython config dir.  Tried %s" % (ipython_dir,))
-    startup_dir = ipython_dir / "profile_default" / "startup"
-    if not startup_dir.isdir:
-        raise RuntimeError(
-            "Couldn't find IPython startup dir.  Tried %s" % (startup_dir,))
-    fn = startup_dir / "50-pyflyby.py"
-    if fn.exists:
-        logger.info("Doing nothing, because %s already exists", fn)
-        return
-    argv = sys.argv[:]
-    argv[0] = os.path.realpath(argv[0])
-    argv = ' '.join(argv)
-    header = (
-        "# File: {fn}\n"
-        "#\n"
-        "# Generated by {argv}\n"
-        "#\n"
-        "# This file causes IPython to enable the Pyflyby Auto Importer.\n"
-        "#\n"
-        "# To uninstall, just delete this file.\n"
-        "#\n"
-    ).format(**locals())
-    contents = header + _generate_enabler_code()
-    logger.info("Installing pyflyby auto importer in your IPython startup")
-    logger.info("Writing to %s:\n%s", fn, contents)
-    atomic_write_file(fn, contents)
-
-
-def _install_in_ipython_config_file_011():
-    """
-    Implementation of `install_in_ipython_config_file` for IPython 0.11.
-    """
-    import IPython
-    ipython_dir = Filename(IPython.utils.path.get_ipython_dir())
-    fn = ipython_dir / "profile_default" / "ipython_config.py"
-    if not fn.exists:
-        raise RuntimeError(
-            "Couldn't find IPython startup file.  Tried %s" % (fn,))
-    old_contents = read_file(fn).joined
-    if re.search(r"^ *(pyflyby[.])?enable_auto_importer[(][)]", old_contents, re.M):
-        logger.info("Doing nothing, because already installed in %s", fn)
-        return
-    header = (
-        "\n"
-        "\n"
-        "#\n"
-        "# Enable the Pyflyby Auto Importer.\n"
-    )
-    new_contents = header + _generate_enabler_code()
-    contents = old_contents.rstrip() + new_contents
-    logger.info("Installing pyflyby auto importer in your IPython startup")
-    logger.info("Appending to %s:\n%s", fn, new_contents)
-    atomic_write_file(fn, contents)
 
 
-def _install_in_ipython_config_file_010():
-    """
-    Implementation of `install_in_ipython_config_file` for IPython 0.10.
-    """
-    import IPython
-    ipython_dir = Filename(IPython.genutils.get_ipython_dir())
-    fn = ipython_dir / "ipy_user_conf.py"
-    if not fn.exists:
-        raise RuntimeError(
-            "Couldn't find IPython config file.  Tried %s" % (fn,))
-    old_contents = read_file(fn).joined
-    if re.search(r"^ *(pyflyby[.])?enable_auto_importer[(][)]", old_contents, re.M):
-        logger.info("Doing nothing, because already installed in %s", fn)
-        return
-    header = (
-        "\n"
-        "\n"
-        "#\n"
-        "# Enable the Pyflyby Auto Importer.\n"
-    )
-    new_contents = header + _generate_enabler_code()
-    contents = old_contents.rstrip() + new_contents
-    logger.info("Installing pyflyby auto importer in your IPython startup")
-    logger.info("Appending to %s:\n%s", fn, new_contents)
-    atomic_write_file(fn, contents)
+
+
 
 
 def _ipython_in_multiline(ip):
@@ -722,37 +565,6 @@ def InterceptPrintsDuringPromptCtx(ip):
             else:
                 return ip.separate_in + ip.prompt_in1.format(ip.execution_count)
         get_prompt = get_prompt_rlipython
-    elif hasattr(ip, "prompt_manager"):
-        # IPython >= 0.12 (known to work including up to 1.2, 2.1)
-        prompt_manager = ip.prompt_manager
-        def get_prompt_ipython_012():
-            pdb_instance = _get_pdb_if_is_in_pdb()
-            if pdb_instance is not None:
-                return pdb_instance.prompt
-            elif _ipython_in_multiline(ip):
-                return prompt_manager.render("in2")
-            else:
-                return ip.separate_in + prompt_manager.render("in")
-        get_prompt = get_prompt_ipython_012
-    elif hasattr(ip.hooks, "generate_prompt"):
-        # IPython 0.10, 0.11
-        generate_prompt = ip.hooks.generate_prompt
-        def get_prompt_ipython_010():
-            pdb_instance = _get_pdb_if_is_in_pdb()
-            if pdb_instance is not None:
-                return pdb_instance.prompt
-            elif _ipython_in_multiline(ip):
-                return generate_prompt(True)
-            else:
-                if hasattr(ip, "outputcache"):
-                    # IPython 0.10 (but not 0.11+):
-                    # Decrement the prompt_count since it otherwise
-                    # auto-increments.  (It's hard to avoid the
-                    # auto-increment as it happens as a side effect of
-                    # __str__!)
-                    ip.outputcache.prompt_count -= 1
-                return generate_prompt(False)
-        get_prompt = get_prompt_ipython_010
     else:
         # Too old or too new IPython version?
         return NullCtx()
@@ -818,8 +630,6 @@ def _get_ipython_app():
         # No active IPython app/shell.
         raise NoActiveIPythonAppError("No active IPython application")
     # The following has been tested on IPython 0.10.
-    if hasattr(IPython, "ipapi"):
-        return _IPython010TerminalApplication.instance()
     raise NoActiveIPythonAppError(
         "Could not figure out how to get active IPython application for IPython version %s"
         % (IPython.__version__,))
@@ -2341,7 +2151,8 @@ class AutoImporter:
             namespaces = get_global_namespaces(self._ip)
 
         def post_import_hook(imp):
-            send_comm_message(MISSING_IMPORTS, {"missing_imports": str(imp)})
+            if not str(imp).startswith(PYFLYBY_LAZY_LOAD_PREFIX):
+                send_comm_message(MISSING_IMPORTS, {"missing_imports": str(imp)})
 
         return self._safe_call(
             auto_import, arg=arg, namespaces=namespaces,