pyflyby 1.8.5__tar.gz → 1.8.7__tar.gz

{pyflyby-1.8.5/lib/python/pyflyby.egg-info → pyflyby-1.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflyby
-Version: 1.8.5
+Version: 1.8.7
 Summary: pyflyby - Python development productivity tools, in particular automatic import management
 Home-page: https://pypi.org/project/pyflyby/
 Author: Karl Chen
@@ -257,7 +257,7 @@ Compatibility
 -------------
 
 Tested with:
-  - Python 3.7, 3.8, 3.9, 3.10
+  - Python 3.8, 3.9, 3.10
   - IPython 0.10, 0.11, 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., 7.11 (latest)
   - IPython (text console), IPython Notebook, Spyder

{pyflyby-1.8.5 → pyflyby-1.8.7}/README.rst

@@ -236,7 +236,7 @@ Compatibility
 -------------
 
 Tested with:
-  - Python 3.7, 3.8, 3.9, 3.10
+  - Python 3.8, 3.9, 3.10
   - IPython 0.10, 0.11, 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., 7.11 (latest)
   - IPython (text console), IPython Notebook, Spyder

{pyflyby-1.8.5 → pyflyby-1.8.7}/bin/pyflyby/_autoimp.py

@@ -609,17 +609,13 @@ class _MissingImportFinder(object):
         #     scope.
         #   - Store the name in the current scope (but not visibly to
         #     args/decorator_list).
-        if sys.version_info >= (3, 8):
-            assert node._fields == ('name', 'args', 'body', 'decorator_list', 'returns', 'type_comment'), node._fields
-        else:
-            assert node._fields == ('name', 'args', 'body', 'decorator_list', 'returns'), node._fields
+        assert node._fields == ('name', 'args', 'body', 'decorator_list', 'returns', 'type_comment'), node._fields
         with self._NewScopeCtx(include_class_scopes=True):
             self.visit(node.args)
             self.visit(node.decorator_list)
             if node.returns:
                 self.visit(node.returns)
-            if sys.version_info >= (3, 8):
-                self._visit_typecomment(node.type_comment)
+            self._visit_typecomment(node.type_comment)
             old_in_FunctionDef = self._in_FunctionDef
             self._in_FunctionDef = True
             with self._NewScopeCtx(unhide_classdef=True):
@@ -671,10 +667,7 @@ class _MissingImportFinder(object):
         self.visit(node)
 
     def visit_arguments(self, node):
-        if sys.version_info >= (3, 8):
-            assert node._fields == ('posonlyargs', 'args', 'vararg', 'kwonlyargs', 'kw_defaults', 'kwarg', 'defaults'), node._fields
-        else:
-            assert node._fields == ('args', 'vararg', 'kwonlyargs', 'kw_defaults', 'kwarg', 'defaults'), node._fields
+        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
         # "Store"s in the function scope.
@@ -693,8 +686,7 @@ class _MissingImportFinder(object):
         # Store arg names.
         self.visit(node.args)
         self.visit(node.kwonlyargs)
-        if sys.version_info >= (3, 8):
-            self.visit(node.posonlyargs)
+        self.visit(node.posonlyargs)
         # may be None.
         if node.vararg:
             self.visit(node.vararg)
@@ -807,16 +799,12 @@ class _MissingImportFinder(object):
         self._visit_fullname(node.id, node.ctx)
 
     def visit_arg(self, node):
-        if sys.version_info >= (3, 8):
-            assert node._fields == ('arg', 'annotation', 'type_comment'), node._fields
-        else:
-            assert node._fields == ('arg', 'annotation'), node._fields
+        assert node._fields == ('arg', 'annotation', 'type_comment'), node._fields
         if node.annotation:
             self.visit(node.annotation)
         # Treat it like a Name node would from Python 2
         self._visit_fullname(node.arg, ast.Param())
-        if sys.version_info >= (3, 8):
-            self._visit_typecomment(node.type_comment)
+        self._visit_typecomment(node.type_comment)
 
     def visit_Attribute(self, node):
         name_revparts = []
@@ -1473,7 +1461,7 @@ def find_missing_imports(arg, namespaces):
       ['x']
 
       >>> # Python 3
-      >>> [str(m) for m in find_missing_imports("[x+y+z for x,y in [(1,2)]], y", [{}])] # doctest: +SKIP
+      >>> [str(m) for m in find_missing_imports("[x+y+z for x,y in [(1,2)]], y", [{}])]
       ['y', 'z']
 
       >>> [str(m) for m in find_missing_imports("(x+y+z for x,y in [(1,2)]), y", [{}])]
@@ -1512,8 +1500,7 @@ def find_missing_imports(arg, namespaces):
             else:
                 return []
         # Parse the string into an AST.
-        kw = {} if sys.version_info < (3, 8) else {'type_comments': True}
-        node = ast.parse(arg, **kw) # may raise SyntaxError
+        node = ast.parse(arg, type_comments=True) # may raise SyntaxError
         # Get missing imports from AST.
         return _find_missing_imports_in_ast(node, namespaces)
     elif isinstance(arg, PythonBlock):

{pyflyby-1.8.5 → pyflyby-1.8.7}/bin/pyflyby/_comms.py

@@ -1,7 +1,12 @@
 
-from   pyflyby._log             import logger
-from   pyflyby._imports2s       import SourceToSourceFileImportsTransformation
+from __future__ import print_function
+
+from   pyflyby._imports2s       import (SourceToSourceFileImportsTransformation,
+                                        SourceToSourceImportBlockTransformation,
+                                        fix_unused_and_missing_imports,
+                                        replace_star_imports)
 from   pyflyby._importstmt      import Import
+from   pyflyby._log             import logger
 import six
 
 # These are comm targets that the frontend (lab/notebook) is expected to
@@ -11,10 +16,11 @@ import six
 MISSING_IMPORTS = "pyflyby.missing_imports"
 FORMATTING_IMPORTS = "pyflyby.format_imports"
 INIT_COMMS = "pyflyby.init_comms"
+TIDY_IMPORTS = "pyflyby.tidy_imports"
 PYFLYBY_START_MSG = "# THIS CELL WAS AUTO-GENERATED BY PYFLYBY\n"
 PYFLYBY_END_MSG = "# END AUTO-GENERATED BLOCK\n"
 
-pyflyby_comm_targets= [MISSING_IMPORTS, FORMATTING_IMPORTS]
+pyflyby_comm_targets= [MISSING_IMPORTS, FORMATTING_IMPORTS, TIDY_IMPORTS]
 
 # A map of the comms opened with a given target name.
 comms = {}
@@ -113,6 +119,41 @@ def _reformat_helper(input_code, imports):
 
     return reformat_import_statements(before + bmarker + middle + emarker + after)
 
+def extract_import_statements(text):
+    """This is a util for notebook interactions and extracts import statements
+    from some python code. This function also re-orders imports.
+    Args:
+        code (str): The code from which import statements have to be extracted
+
+    Returns:
+        (str, str): The first returned value contains all the import statements.
+        The second returned value is the remaining code after
+        extracting the import statements.
+    """
+    transformer = SourceToSourceFileImportsTransformation(text)
+    imports = '\n'.join([str(im.pretty_print()) for im in transformer.import_blocks])
+    remaining_code = "\n".join([str(st.pretty_print()) if not isinstance(st, SourceToSourceImportBlockTransformation) else "" for st in transformer.blocks])
+    return imports, remaining_code
+
+def collect_code_with_imports_on_top(imports: str, cell_array):
+    return (
+        imports
+        + "\n"
+        + "\n".join(
+            [
+                cell["text"] if cell["type"] == "code" else ""
+                for cell in cell_array
+            ]
+        )
+    )
+
+def run_tidy_imports(code):
+   return str(
+        fix_unused_and_missing_imports(
+            replace_star_imports(code)
+        )
+    )
+
 def comm_open_handler(comm, message):
     """
     Handles comm_open message for pyflyby custom comm messages.
@@ -130,7 +171,41 @@ def comm_open_handler(comm, message):
     def _recv(msg):
         data = msg["content"]["data"]
         if data["type"] == FORMATTING_IMPORTS:
-            msg_id = data.get('msg_id', None)
-            imports = data.get('imports', None)
+            msg_id = data.get("msg_id", None)
+            imports = data.get("imports", None)
             fmt_code = _reformat_helper(data["input_code"], imports)
-            comm.send({"msg_id": msg_id, "formatted_code": str(fmt_code), "type": FORMATTING_IMPORTS})
+            comm.send(
+                {
+                    "msg_id": msg_id,
+                    "formatted_code": str(fmt_code),
+                    "type": FORMATTING_IMPORTS,
+                }
+            )
+        elif data["type"] == TIDY_IMPORTS:
+            checksum = data.get("checksum", '')
+            cell_array = data.get("cellArray", [])
+            # import_statements is a string because when
+            # SourceToSourceFileImportsTransformation is run on a piece of code
+            # it will club similar imports together and re-order the imports
+            # by making the imports a string, all the imports are processed
+            # together making sure tidy-imports has context on all the imports
+            # while clubbing similar imports and re-ordering them.
+            import_statements, processed_cell_array = "", []
+            for cell in cell_array:
+                text = cell.get("text")
+                cell_type = cell.get("type")
+                if cell_type == "code":
+                    imports, text = extract_import_statements(text)
+                    import_statements += imports
+                processed_cell_array.append({"text": text, "type": cell_type})
+            code_with_collected_imports = collect_code_with_imports_on_top(import_statements, processed_cell_array)
+            code_post_tidy_imports = run_tidy_imports(code_with_collected_imports)
+            import_statements, _ = extract_import_statements(code_post_tidy_imports)
+            comm.send(
+                {
+                    "checksum": checksum,
+                    "type": TIDY_IMPORTS,
+                    "cells": processed_cell_array,
+                    "imports": import_statements,
+                }
+            )

{pyflyby-1.8.5 → pyflyby-1.8.7}/bin/pyflyby/_idents.py

@@ -194,7 +194,7 @@ class DottedIdentifier(object):
         return (type(self)(x) for x in self.parts)
 
     def __add__(self, suffix):
-        return type(self)("%s.%s") % (self, suffix)
+        return type(self)("%s.%s" % (self, suffix))
 
     def __str__(self):
         return self.name

{pyflyby-1.8.5 → pyflyby-1.8.7}/bin/pyflyby/_imports2s.py

@@ -1,9 +1,9 @@
 # pyflyby/_imports2s.py.
 # Copyright (C) 2011-2018 Karl Chen.
 # License: MIT http://opensource.org/licenses/MIT
+from collections import defaultdict
 
-
-
+import isort
 from   pyflyby._autoimp         import scan_for_import_issues
 from   pyflyby._file            import FileText, Filename
 from   pyflyby._flags           import CompilerFlags
@@ -534,6 +534,48 @@ def replace_star_imports(codeblock, params=None):
     return transformer.output(params=params)
 
 
+def sort_imports(codeblock):
+    """
+    Sort imports for better grouping.
+    :param codeblock:
+    :return: codeblock
+    """
+    sorted_imports = isort.code(
+        str(codeblock),
+        # To sort all the import in lexicographic order
+        force_sort_within_sections=True,
+        # This is done below
+        lines_between_sections=0,
+        lines_after_imports=1
+    )
+    # Step 1: Split the input string into a list of lines
+    lines = sorted_imports.split('\n')
+
+    # Step 2: Identify groups of imports and keep track of their line numbers
+    pkg_lines = defaultdict(list)
+    line_pkg_dict = {}
+    for i, line in enumerate(lines):
+        match = re.match(r'(from (\w+)|import (\w+))', line)
+        if match:
+            current_pkg = match.groups()[1:3]
+            current_pkg = current_pkg[0] if current_pkg[0] is not None else current_pkg[1]
+            pkg_lines[current_pkg].append(i)
+            line_pkg_dict[i] = current_pkg
+
+    # Step 3: Create the output list of lines with blank lines around groups with more than one import
+    output_lines = []
+    for i, line in enumerate(lines):
+        if i > 0 and line_pkg_dict.get(i) != line_pkg_dict.get(i-1) and len(pkg_lines[line_pkg_dict.get(i)]) > 1:
+            output_lines.append('')
+        output_lines.append(line)
+        if i < len(lines) - 1 and line_pkg_dict.get(i) != line_pkg_dict.get(i+1) and len(pkg_lines[line_pkg_dict.get(i)]) > 1:
+            output_lines.append('')
+
+    # Step 4: Join the lines to create the output string
+    sorted_output_str = '\n'.join(output_lines)
+    return PythonBlock(sorted_output_str)
+
+
 def transform_imports(codeblock, transformations, params=None):
     """
     Transform imports as specified by ``transformations``.

{pyflyby-1.8.5 → pyflyby-1.8.7}/bin/pyflyby/_modules.py

@@ -4,7 +4,10 @@
 
 
 
+
+import ast
 from   functools                import total_ordering
+import itertools
 import os
 import re
 import six
@@ -67,13 +70,13 @@ def import_module(module_name):
                      real_importerror1, real_importerror2, real_importerror3)
         if real_importerror1 and real_importerror2 and real_importerror3:
             raise
-        reraise(ErrorDuringImportError(
+        reraise(ErrorDuringImportError, ErrorDuringImportError(
             "Error while attempting to import %s: %s: %s"
-            % (module_name, type(e).__name__, e)), None, sys.exc_info()[2])
+            % (module_name, type(e).__name__, e)), sys.exc_info()[2])
     except Exception as e:
-        reraise(ErrorDuringImportError(
+        reraise(ErrorDuringImportError, ErrorDuringImportError(
             "Error while attempting to import %s: %s: %s"
-            % (module_name, type(e).__name__, e)), None, sys.exc_info()[2])
+            % (module_name, type(e).__name__, e)), sys.exc_info()[2])
 
 
 def _my_iter_modules(path, prefix=''):
@@ -320,13 +323,26 @@ class ModuleHandle(object):
         return tuple(ModuleHandle("%s.%s" % (self.name,m))
                      for m in sorted(set(submodule_names)))
 
+    @staticmethod
+    def _member_from_node(node):
+        extractors = {
+            # Top-level assignments (as opposed to member assignments
+            # whose targets are of type ast.Attribute).
+            ast.Assign: lambda x: [t.id for t in x.targets if isinstance(t, ast.Name)],
+            ast.ClassDef: lambda x: [x.name],
+            ast.FunctionDef: lambda x: [x.name],
+        }
+        if isinstance(node, tuple(extractors.keys())):
+            return extractors[type(node)](node)
+        return []
+
     @cached_attribute
     def exports(self):
         """
         Get symbols exported by this module.
 
-        Note that this requires involves actually importing this module, which
-        may have side effects.  (TODO: rewrite to avoid this?)
+        Note that this will not recognize symbols that are dynamically
+        introduced to the module's namespace or __all__ list.
 
         :rtype:
           `ImportSet` or ``None``
@@ -334,28 +350,72 @@ class ModuleHandle(object):
           Exports, or ``None`` if nothing exported.
         """
         from pyflyby._importclns import ImportStatement, ImportSet
-        module = self.module
-        try:
-            members = module.__all__
-        except AttributeError:
-            members = dir(module)
-            # Filter by non-private.
-            members = [n for n in members if not n.startswith("_")]
-            # Filter by definition in the module.
-            def from_this_module(name):
-                # TODO: could do this more robustly by parsing the AST and
-                # looking for STOREs (definitions/assignments/etc).
-                x = getattr(module, name)
-                m = getattr(x, "__module__", None)
-                if not m:
-                    return False
-                return DottedIdentifier(m).startswith(self.name)
-            members = [n for n in members if from_this_module(n)]
-        else:
+
+        filename = getattr(self, 'filename', None)
+        if not filename or not filename.exists:
+            # Try to load the module to get the filename
+            filename = Filename(self.module.__file__)
+        text = FileText(filename)
+
+        ast_mod = ast.parse(str(text), str(filename)).body
+
+        # First, add members that are explicitly defined in the module
+        members = list(itertools.chain(*[self._member_from_node(n) \
+                                         for n in ast_mod]))
+
+        # If __all__ is defined, try to use it
+        all_is_good = False  # pun intended
+        if "__all__" in members:
+            # Iterate through the nodes and reconstruct the
+            # value of __all__
+            for n in ast_mod:
+                if isinstance(n, ast.Assign):
+                    if "__all__" in self._member_from_node(n):
+                        try:
+                            all_members = list(ast.literal_eval(n.value))
+                            all_is_good = True
+                        except (ValueError, TypeError):
+                            all_is_good = False
+                elif isinstance(n, ast.AugAssign) and \
+                     isinstance(n.target, ast.Name) and \
+                     n.target.id == "__all__" and all_is_good:
+                    try:
+                        all_members += list(ast.literal_eval(n.value))
+                    except (ValueError, TypeError):
+                        all_is_good = False
             if not all(type(s) == str for s in members):
                 raise Exception(
                     "Module %r contains non-string entries in __all__"
                     % (str(self.name),))
+
+        if all_is_good:
+            members = all_members
+        else:
+            # Add "from" imports that belong to submodules
+            # (note: this will fail to recognize implicit relative imports)
+            imp_nodes = [n for n in ast_mod if isinstance(n, ast.ImportFrom)]
+            for imp_node in imp_nodes:
+                if imp_node.level == 0:
+                    from_mod = DottedIdentifier(imp_node.module)
+                    if not from_mod.startswith(self.name):
+                        continue
+                elif imp_node.level == 1 and \
+                     filename.base == "__init__.py":
+                    # Special case: a relative import can be from a submodule only if
+                    # our module's filename is  __init__.py.
+                    from_mod = self.name
+                    if imp_node.module:
+                        from_mod += imp_node.module
+                else:
+                    continue
+                for n in imp_node.names:
+                    m  = n.asname or n.name
+                    if n.name != "*" and not ModuleHandle(from_mod + m).exists:
+                        members.append(m)
+
+        # Filter by non-private.
+        members = [n for n in members if not n.startswith("_")]
+
         # Filter out artificially added "deep" members.
         members = [(n, None) for n in members if "." not in n]
         if not members:

{pyflyby-1.8.5/lib/python → pyflyby-1.8.7/bin}/pyflyby/_parse.py

@@ -24,19 +24,7 @@ from   pyflyby._util            import cached_attribute, cmp
 
 from ast import Bytes
 
-if sys.version_info >= (3, 8):
-    from ast import TypeIgnore, AsyncFunctionDef
-else:
-
-    # TypeIgnore, AsyncFunctionDef does not exist on Python 3.7 and before. thus
-    # we define a dummy TypeIgnore, AsyncFunctionDef just to simplify remaining
-    # code.
-
-    class TypeIgnore:
-        pass
-
-    class AsyncFunctionDef:
-        pass
+from ast import TypeIgnore, AsyncFunctionDef
 
 
 def _is_comment_or_blank(line):
@@ -104,37 +92,27 @@ def _iter_child_nodes_in_order_internal_1(node):
         assert node._fields == ("keys", "values")
         yield list(zip(node.keys, node.values))
     elif isinstance(node, (ast.FunctionDef, AsyncFunctionDef)):
-        if sys.version_info >= (3, 8):
-            assert node._fields == (
-                "name",
-                "args",
-                "body",
-                "decorator_list",
-                "returns",
-                "type_comment",
-            ), node._fields
-            res = (
-                node.type_comment,
-                node.decorator_list,
-                node.args,
-                node.returns,
-                node.body,
-            )
-            yield res
-        else:
-            assert node._fields == ('name', 'args', 'body', 'decorator_list',
-                                    'returns'), node._fields
-            yield node.decorator_list, node.args, node.returns, node.body
+        assert node._fields == (
+            "name",
+            "args",
+            "body",
+            "decorator_list",
+            "returns",
+            "type_comment",
+        ), node._fields
+        res = (
+            node.type_comment,
+            node.decorator_list,
+            node.args,
+            node.returns,
+            node.body,
+        )
+        yield res
         # node.name is a string, not an AST node
     elif isinstance(node, ast.arguments):
-        if sys.version_info >= (3, 8):
-            assert node._fields == ('posonlyargs', 'args', 'vararg', 'kwonlyargs',
-                                    'kw_defaults', 'kwarg', 'defaults'), node._fields
-            args = node.posonlyargs + node.args
-        else:
-            assert node._fields == ('args', 'vararg', 'kwonlyargs',
-                                    'kw_defaults', 'kwarg', 'defaults'), node._fields
-            args = node.args
+        assert node._fields == ('posonlyargs', 'args', 'vararg', 'kwonlyargs',
+                                'kw_defaults', 'kwarg', 'defaults'), node._fields
+        args = node.posonlyargs + node.args
         defaults = node.defaults or ()
         num_no_default = len(args) - len(defaults)
         yield args[:num_no_default]
@@ -153,7 +131,7 @@ def _iter_child_nodes_in_order_internal_1(node):
         assert node._fields == ('name', 'bases', 'keywords', 'body', 'decorator_list')
         yield node.decorator_list, node.bases, node.body
         # node.name is a string, not an AST node
-    elif sys.version_info >= (3, 7) and isinstance(node, ast.FormattedValue):
+    elif isinstance(node, ast.FormattedValue):
         assert node._fields == ('value', 'conversion', 'format_spec')
         yield node.value,
     else:
@@ -187,22 +165,10 @@ def _flags_to_try(source, flags, auto_flags, mode):
     If ``auto_flags`` is True, then yield ``flags`` and ``flags ^ print_function``.
     """
     flags = CompilerFlags(flags)
-    if sys.version_info >= (3, 8):
-        if re.search(r"# *type:", source):
-            flags = flags | CompilerFlags('type_comments')
-        yield flags
-        return
-    if not auto_flags:
-        yield flags
-        return
-    if mode == "eval":
-        if re.search(r"\bprint\b", source):
-            flags = flags | CompilerFlags("print_function")
-        yield flags
-        return
+    if re.search(r"# *type:", source):
+        flags = flags | CompilerFlags('type_comments')
     yield flags
-    if re.search(r"\bprint\b", source):
-        yield flags ^ CompilerFlags("print_function")
+    return
 
 
 def _parse_ast_nodes(text, flags, auto_flags, mode):
@@ -348,14 +314,6 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
     """
     assert isinstance(ast_node, (ast.AST, str, TypeIgnore)), ast_node
 
-    # joined strings and children do not carry a column offset on pre-3.8
-    # this prevent reformatting.
-    # set the column offset to the parent value before 3.8
-    if (3, 7) < sys.version_info < (3, 8):
-        instances = (getattr(ast, "JoinedStr", None), ast.FormattedValue)
-        if ((isinstance(ast_node, instances) or isinstance(parent_ast_node, instances)) and ast_node.col_offset == -1) or isinstance(ast_node, ast.keyword):
-            ast_node.col_offset = parent_ast_node.col_offset
-
     # First, traverse child nodes.  If the first child node (recursively) is a
     # multiline string, then we need to transfer its information to this node.
     # Walk all nodes/fields of the AST.  We implement this as a custom
@@ -400,9 +358,8 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
     if ast_node.col_offset >= 0:
         # In Python 3.8+, FunctionDef.lineno is the line with the def. To
         # account for decorators, we need the lineno of the first decorator
-        if (sys.version_info >= (3, 8)
-            and isinstance(ast_node, (ast.FunctionDef, ast.ClassDef, AsyncFunctionDef))
-            and ast_node.decorator_list):
+        if (isinstance(ast_node, (ast.FunctionDef, ast.ClassDef, AsyncFunctionDef))
+                and ast_node.decorator_list):
             delta = (ast_node.decorator_list[0].lineno-1,
                      # The col_offset doesn't include the @
                      ast_node.decorator_list[0].col_offset - 1)
@@ -426,20 +383,6 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
         # Since we use startpos for breaking lines, we need to set startpos to
         # the beginning of the line.
         # In Python 3, the col_offset for the with is 0 again.
-        if (isinstance(ast_node, ast.With) and
-            not isinstance(parent_ast_node, ast.With) and
-            sys.version_info[:2] == (2,7)):
-            assert ast_node.col_offset >= 5
-            if startpos.lineno == text.startpos.lineno:
-                linestart = text.startpos.colno
-            else:
-                linestart = 1
-            line = text[(startpos.lineno,linestart):startpos]
-            m = re.search(r"\bwith\s+$", str(line))
-            assert m
-            lk = len(m.group()) # length of 'with   ' including spaces
-            startpos = FilePos(startpos.lineno, startpos.colno - lk)
-            assert str(text[startpos:(startpos+(0,4))]) == "with"
         ast_node.startpos = startpos
         if sys.version_info <= (3, 8):
             ast_node.startpos = max(startpos, minpos)
@@ -472,7 +415,7 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
 
     # It should now be the case that we are looking at a multi-line string
     # literal.
-    if sys.version_info >= (3, 7) and isinstance(ast_node, ast.FormattedValue):
+    if isinstance(ast_node, ast.FormattedValue):
         ast_node.startpos = ast_node.value.startpos
         ast_node.endpos = ast_node.value.startpos
 
@@ -500,9 +443,6 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
             for _m in re.finditer("[bBrRuU]*[\"\']", start_line)])
     target_str = ast_node.s
 
-    if isinstance(target_str, bytes) and sys.version_info[:2] == (3, 7):
-        target_str = target_str.decode()
-
     # Loop over possible end_linenos.  The first one we've identified is the
     # by far most likely one, but in theory it could be anywhere later in the
     # file.  This could be because of a dastardly concatenated string like
@@ -567,18 +507,8 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
             candidate_str = _test_parse_string_literal(subtext, flags)
             if candidate_str is None:
                 continue
-            if isinstance(candidate_str, bytes) and sys.version_info[:2] == (3, 7):
-                candidate_str = candidate_str.decode()
 
             maybe_fstring = False
-            try:
-                if (3, 7) <= sys.version_info <= (3, 8):
-                    potential_start = text.lines[startpos.lineno - 1]
-                    maybe_fstring = ("f'" in potential_start) or (
-                        'f"' in potential_start
-                    )
-            except IndexError:
-                pass
 
             if target_str == candidate_str and target_str:
                 # Success!
@@ -603,17 +533,6 @@ def _annotate_ast_startpos(ast_node, parent_ast_node, minpos, text, flags):
             for (sq, sp) in startpos_candidates
             if sp in matched_prefix
         ]
-    if (3, 7) <= sys.version_info <= (3, 8):
-        if len(f_string_candidate_prefixes) == 1:
-            # we did not find the string but there is one fstring candidate starting it
-
-            ast_node.startpos, ast_node.endpos = f_string_candidate_prefixes[0]
-            return True
-        elif isinstance(parent_ast_node, ast.JoinedStr):
-            self_pos = parent_ast_node.values.index(ast_node)
-            ast_node.startpos = parent_ast_node.values[self_pos - 1].startpos
-            ast_node.endpos = parent_ast_node.values[self_pos - 1].endpos
-            return True
     raise ValueError("Couldn't find exact position of %s" % (ast.dump(ast_node)))
 
 
@@ -801,7 +720,7 @@ class PythonStatement(object):
     comments/blank lines.
 
       >>> PythonStatement('print("x",\n file=None)\n', flags='print_function')  #doctest: +SKIP
-      PythonStatement('print("x",\n file=None)\n', flags=0x10000)
+      PythonStatement('print("x",\n file=None)\n', flags=0x100000)
 
     Implemented as a wrapper around a `PythonBlock` containing at most one
     top-level AST node.