pyflyby 1.9.8__tar.gz → 1.9.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflyby
-Version: 1.9.8
+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

{pyflyby-1.9.8 → pyflyby-1.9.9}/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.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.8/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.8/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:

{pyflyby-1.9.8 → 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.8 → pyflyby-1.9.9}/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,

{pyflyby-1.9.8/lib/python → pyflyby-1.9.9/bin}/pyflyby/_parse.py

@@ -346,9 +346,6 @@ def _annotate_ast_nodes(ast_node: ast.AST) -> AnnotatedAst:
     flags = aast_node.flags
     startpos = text.startpos
     _annotate_ast_startpos(aast_node, None, startpos, text, flags)
-    # Not used for now:
-    #   ast_node.context = AstNodeContext(None, None, None)
-    #   _annotate_ast_context(ast_node)
     return aast_node
 
 
@@ -526,29 +523,6 @@ def _annotate_ast_startpos(
     raise ValueError("Couldn't find exact position of %s" % (ast.dump(ast_node)))
 
 
-def _annotate_ast_context(ast_node):
-    """
-    Recursively annotate ``context`` on ast nodes, setting ``context`` to
-    a `AstNodeContext` named tuple with values
-    ``(parent, field, index)``.
-    Each aast_node satisfies ``parent.<field>[<index>] is ast_node``.
-
-    For non-list fields, the index part is ``None``.
-    """
-    assert isinstance(ast_node, ast.AST)
-    for field_name, field_value in ast.iter_fields(ast_node):
-        if isinstance(field_value, ast.AST):
-            child_node = field_value
-            child_node.context = AstNodeContext(ast_node, field_name, None)
-            _annotate_ast_context(child_node)
-        elif isinstance(field_value, list):
-            for i, item in enumerate(field_value):
-                if isinstance(item, ast.AST):
-                    child_node = item
-                    child_node.context = AstNodeContext(ast_node, field_name, i)
-                    _annotate_ast_context(child_node)
-
-
 def _split_code_lines(ast_nodes, text):
     """
     Split the given ``ast_nodes`` and corresponding ``text`` by code/noncode
@@ -632,51 +606,6 @@ def _split_code_lines(ast_nodes, text):
             yield ([], text[endpos:next_startpos])
 
 
-def _ast_node_is_in_docstring_position(ast_node):
-    """
-    Given a ``Str`` AST node, return whether its position within the AST makes
-    it eligible as a docstring.
-
-    The main way a ``Str`` can be a docstring is if it is a standalone string
-    at the beginning of a ``Module``, ``FunctionDef``, ``AsyncFucntionDef``
-    or ``ClassDef``.
-
-    We also support variable docstrings per Epydoc:
-
-      - If a variable assignment statement is immediately followed by a bare
-        string literal, then that assignment is treated as a docstring for
-        that variable.
-
-    :type ast_node:
-      ``ast.Str``
-    :param ast_node:
-      AST node that has been annotated by ``_annotate_ast_nodes``.
-    :rtype:
-      ``bool``
-    :return:
-      Whether this string ast node is in docstring position.
-    """
-    if not _is_ast_str_or_byte(ast_node):
-        raise TypeError
-    expr_node = ast_node.context.parent
-    if not isinstance(expr_node, ast.Expr):
-        return False
-    assert ast_node.context.field == 'value'
-    assert ast_node.context.index is None
-    expr_ctx = expr_node.context
-    if expr_ctx.field != 'body':
-        return False
-    parent_node = expr_ctx.parent
-    if not isinstance(parent_node, (ast.FunctionDef, ast.ClassDef, ast.Module, AsyncFunctionDef)):
-        return False
-    if expr_ctx.index == 0:
-        return True
-    prev_sibling_node = parent_node.body[expr_ctx.index-1]
-    if isinstance(prev_sibling_node, ast.Assign):
-        return True
-    return False
-
-
 def infer_compile_mode(arg:ast.AST) -> Literal['exec','eval','single']:
     """
     Infer the mode needed to compile ``arg``.
@@ -1334,11 +1263,6 @@ class PythonBlock:
         #   - This function yields multiple docstrings (even per ast node)
         #   - This function doesn't raise TypeError on other AST types
         #   - This function doesn't cleandoc
-        # A previous implementation did
-        #   [n for n in self.string_literals()
-        #    if _ast_node_is_in_docstring_position(n)]
-        # However, the method we now use is more straightforward, and doesn't
-        # require first annotating each node with context information.
         docstring_containers = (ast.FunctionDef, ast.ClassDef, ast.Module, AsyncFunctionDef)
         for node in _walk_ast_nodes_in_order(self.annotated_ast_node):
             if not isinstance(node, docstring_containers):