# Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"++        statements.append(block)++    return statements+++def normalize_lines(selection):+    """+    Normalize the text selection received from the extension and send it to the REPL. +    If it is a single line selection, dedent it, append a newline and send it to the REPL.+    Otherwise, sanitize the multiline selection before sending it to the REPL:+    split it in a list of top-level statements+    and add newlines between each of them to tell the REPL where each block ends.+    """ -def _get_global_statement_blocks(source, lines):-    """Return a list of all global statement blocks.+    # Check if it is a singleline or multiline selection.+    is_singleline = len(selection.splitlines()) == 1 -    The list comprises of 3-item tuples that contain the starting line number,-    ending line number and whether the statement is a single line.+    # If it is a single line statement: Dedent and skip to the end.+    # Else: Parse the multiline selection into a list of top-level blocks.+    if is_singleline:+        statements = [textwrap.dedent(selection)]

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"++        statements.append(block)++    return statements+++def normalize_lines(selection):+    """+    Normalize the text selection received from the extension and send it to the REPL. +    If it is a single line selection, dedent it, append a newline and send it to the REPL.+    Otherwise, sanitize the multiline selection before sending it to the REPL:+    split it in a list of top-level statements+    and add newlines between each of them to tell the REPL where each block ends.+    """ -def _get_global_statement_blocks(source, lines):-    """Return a list of all global statement blocks.+    # Check if it is a singleline or multiline selection.+    is_singleline = len(selection.splitlines()) == 1 -    The list comprises of 3-item tuples that contain the starting line number,-    ending line number and whether the statement is a single line.+    # If it is a single line statement: Dedent and skip to the end.+    # Else: Parse the multiline selection into a list of top-level blocks.+    if is_singleline:+        statements = [textwrap.dedent(selection)]

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"++        statements.append(block)++    return statements+++def normalize_lines(selection):+    """+    Normalize the text selection received from the extension and send it to the REPL. +    If it is a single line selection, dedent it, append a newline and send it to the REPL.+    Otherwise, sanitize the multiline selection before sending it to the REPL:+    split it in a list of top-level statements+    and add newlines between each of them to tell the REPL where each block ends.+    """ -def _get_global_statement_blocks(source, lines):-    """Return a list of all global statement blocks.+    # Check if it is a singleline or multiline selection.+    is_singleline = len(selection.splitlines()) == 1 -    The list comprises of 3-item tuples that contain the starting line number,-    ending line number and whether the statement is a single line.+    # If it is a single line statement: Dedent and skip to the end.+    # Else: Parse the multiline selection into a list of top-level blocks.+    if is_singleline:+        statements = [textwrap.dedent(selection)]+    else:+        statements = _get_multiline_statements(selection) -    """-    tree = ast.parse(source)-    visitor = Visitor(lines)-    visitor.visit(tree)--    statement_ranges = []-    for index, line_number in enumerate(visitor.line_numbers_with_statements):-        remaining_line_numbers = visitor.line_numbers_with_statements[index + 1 :]-        end_line_number = (-            len(lines)-            if len(remaining_line_numbers) == 0-            else min(remaining_line_numbers) - 1-        )-        current_statement_is_oneline = line_number == end_line_number--        if len(statement_ranges) == 0:-            statement_ranges.append(-                (line_number, end_line_number, current_statement_is_oneline)-            )-            continue--        previous_statement = statement_ranges[-1]-        previous_statement_is_oneline = previous_statement[2]-        if previous_statement_is_oneline and current_statement_is_oneline:-            statement_ranges[-1] = previous_statement[0], end_line_number, True-        else:-            statement_ranges.append(-                (line_number, end_line_number, current_statement_is_oneline)-            )--    return statement_ranges---def normalize_lines(source):-    """Normalize blank lines for sending to the terminal.--    Blank lines within a statement block are removed to prevent the REPL-    from thinking the block is finished. Newlines are added to separate-    top-level statements so that the REPL does not think there is a syntax-    error.+    # Insert a newline between each top-level statement, and append a newline to the selection.+    source = "\n".join(statements) + "\n" -    """-    # Ensure to dedent the code (#2837)-    lines = textwrap.dedent(source).splitlines(False)-    # If we have two blank lines, then add two blank lines.-    # Do not trim the spaces, if we have blank lines with spaces, its possible-    # we have indented code.-    if (len(lines) > 1 and len("".join(lines[-2:])) == 0) or source.endswith(-        ("\n\n", "\r\n\r\n")-    ):-        trailing_newline = "\n" * 2-    # Find out if we have any trailing blank lines-    elif len(lines[-1].strip()) == 0 or source.endswith(("\n", "\r\n")):-        trailing_newline = "\n"-    else:-        trailing_newline = ""--    # Step 1: Remove empty lines.-    tokens = _tokenize(source)-    newlines_indexes_to_remove = (-        spos[0]-        for (toknum, tokval, spos, epos, line) in tokens-        if len(line.strip()) == 0-        and token.tok_name[toknum] == "NL"-        and spos[0] == epos[0]-    )--    for line_number in reversed(list(newlines_indexes_to_remove)):-        del lines[line_number - 1]--    # Step 2: Add blank lines between each global statement block.-    # A consecutive single lines blocks of code will be treated as a single statement,-    # just to ensure we do not unnecessarily add too many blank lines.-    source = "\n".join(lines)-    tokens = _tokenize(source)-    dedent_indexes = (-        spos[0]-        for (toknum, tokval, spos, epos, line) in tokens-        if toknum == token.DEDENT and _indent_size(line) == 0-    )--    global_statement_ranges = _get_global_statement_blocks(source, lines)-    start_positions = map(operator.itemgetter(0), reversed(global_statement_ranges))-    for line_number in filter(lambda x: x > 1, start_positions):-        lines.insert(line_number - 1, "")--    sys.stdout.write("\n".join(lines) + trailing_newline)+    # Finally, send the formatted selection to the REPL.+    sys.stdout.write(source)

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"++        statements.append(block)++    return statements+++def normalize_lines(selection):+    """+    Normalize the text selection received from the extension and send it to the REPL. +    If it is a single line selection, dedent it, append a newline and send it to the REPL.+    Otherwise, sanitize the multiline selection before sending it to the REPL:+    split it in a list of top-level statements+    and add newlines between each of them to tell the REPL where each block ends.+    """ -def _get_global_statement_blocks(source, lines):-    """Return a list of all global statement blocks.+    # Check if it is a singleline or multiline selection.+    is_singleline = len(selection.splitlines()) == 1 -    The list comprises of 3-item tuples that contain the starting line number,-    ending line number and whether the statement is a single line.+    # If it is a single line statement: Dedent and skip to the end.+    # Else: Parse the multiline selection into a list of top-level blocks.+    if is_singleline:+        statements = [textwrap.dedent(selection)]

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"++        statements.append(block)++    return statements+++def normalize_lines(selection):+    """+    Normalize the text selection received from the extension and send it to the REPL. +    If it is a single line selection, dedent it, append a newline and send it to the REPL.+    Otherwise, sanitize the multiline selection before sending it to the REPL:+    split it in a list of top-level statements+    and add newlines between each of them to tell the REPL where each block ends.+    """ -def _get_global_statement_blocks(source, lines):-    """Return a list of all global statement blocks.+    # Check if it is a singleline or multiline selection.+    is_singleline = len(selection.splitlines()) == 1 -    The list comprises of 3-item tuples that contain the starting line number,-    ending line number and whether the statement is a single line.+    # If it is a single line statement: Dedent and skip to the end.+    # Else: Parse the multiline selection into a list of top-level blocks.+    if is_singleline:+        statements = [textwrap.dedent(selection)]+    else:+        statements = _get_multiline_statements(selection)

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"++        statements.append(block)++    return statements+++def normalize_lines(selection):+    """+    Normalize the text selection received from the extension and send it to the REPL. +    If it is a single line selection, dedent it, append a newline and send it to the REPL.+    Otherwise, sanitize the multiline selection before sending it to the REPL:+    split it in a list of top-level statements+    and add newlines between each of them to tell the REPL where each block ends.+    """ -def _get_global_statement_blocks(source, lines):-    """Return a list of all global statement blocks.+    # Check if it is a singleline or multiline selection.+    is_singleline = len(selection.splitlines()) == 1

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""]

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):+        # Given this selection:+        # if (m > 0 and+        #        n < 3):+        #     print('foo')+        # value = 'bar'+        #+        # The first block would have lineno = 1,and the second block lineno = 4+        start = node.lineno - 1+        end = len(lines) if idx == last_idx else tree.body[idx + 1].lineno - 1+        block = "\n".join(lines[start:end])++        # If the block is multiline, add an extra newline character at its end.+        # This way, when joining blocks back together, there will be a blank line between each multiline statement+        # and no blank lines between single-line statements, or it would look like this:+        # >>> x = 22+        # >>>+        # >>> y = 30+        # >>>+        # >>> total = x + y+        # >>>+        if end - start > 1:+            block += "\n"

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""] +    # Dedent the selection and parse it using the ast module.+    # Note that leading comments in the selection will be discarded during parsing.+    source = textwrap.dedent("\n".join(lines))+    tree = ast.parse(source) -def _indent_size(line):-    for index, char in enumerate(line):-        if not char.isspace():-            return index+    # We'll need the dedented lines to rebuild the selection.+    lines = source.splitlines(False)++    # Get the line ranges for top-level blocks returned from parsing the dedented text+    # and split the selection accordingly.+    # tree.body is a list of AST objects, which we rely on to extract top-level statements.+    # If we supported Python 3.8+ only we could use the lineno and end_lineno attributes of each object+    # to get the boundaries of each block.+    # However, earlier Python versions only have the lineno attribute, which is the range start position (1-indexed).+    # Therefore, to retrieve the end line of each block in a version-agnostic way we need to do+    # `end = next_block.lineno - 1`+    # for all blocks except the last one, which will will just run until the last line.+    last_idx = len(tree.body) - 1+    for idx, node in enumerate(tree.body):

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""]

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = [] -def _tokenize(source):-    """Tokenize Python source code."""-    # Using an undocumented API as the documented one in Python 2.7 does not work as needed-    # cross-version.-    if sys.version_info < (3,) and isinstance(source, str):-        source = source.decode()-    return tokenize.generate_tokens(io.StringIO(source).readline)+    # Remove blank lines within the selection to prevent the REPL from thinking the block is finished.+    lines = [line for line in selection.splitlines(False) if line.strip() != ""]

 # Licensed under the MIT License.  import ast-import io-import operator-import os-import sys import textwrap-import token-import tokenize---class Visitor(ast.NodeVisitor):-    def __init__(self, lines):-        self._lines = lines-        self.line_numbers_with_nodes = set()-        self.line_numbers_with_statements = []--    def generic_visit(self, node):-        if (-            hasattr(node, "col_offset")-            and hasattr(node, "lineno")-            and node.col_offset == 0-        ):-            self.line_numbers_with_nodes.add(node.lineno)-            if isinstance(node, ast.stmt):-                self.line_numbers_with_statements.append(node.lineno)+import sys -        ast.NodeVisitor.generic_visit(self, node) +def _get_multiline_statements(selection):+    """+    Process a multiline selection into a list of its top-level statements.+    This will remove empty newlines around and within the selection, dedent it,+    and split it using the result of `ast.parse()`.+    """+    statements = []

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import { traceVerbose } from '../../../../common/logger';+import { chain, iterable } from '../../../../common/utils/async';+import {+    getEnvironmentVariable, getUserHomeDir,+} from '../../../../common/utils/platform';+import {+    PythonEnvInfo, PythonEnvKind, UNKNOWN_PYTHON_VERSION,+} from '../../../base/info';+import { buildEnvInfo } from '../../../base/info/env';+import { ILocator, IPythonEnvsIterator } from '../../../base/locator';+import { PythonEnvsWatcher } from '../../../base/watcher';+import { findInterpretersInDir } from '../../../common/commonUtils';+import { getFileInfo, pathExists } from '../../../common/externalDependencies';+import { isVenvEnvironment, isVirtualenvEnvironment, isVirtualenvwrapperEnvironment } from './virtualEnvironmentIdentifier';++const DEFAULT_SEARCH_DEPTH = 2;++/**+ * Gets all default virtual environment locations. This uses WORKON_HOME,+ * and user home directory to find some known locations where global virtual+ * environments are often created.+ */+async function getGlobalVirtualEnvDirs(): Promise<string[]> {+    const venvDirs:string[] = [];++    const workOnHome = getEnvironmentVariable('WORKON_HOME');+    if (workOnHome && await pathExists(workOnHome)) {+        venvDirs.push(workOnHome);+    }++    const homeDir = getUserHomeDir();+    if (homeDir && await pathExists(homeDir)) {+        const subDirs = ['Envs', 'envs', '.direnv', '.venvs', '.virtualenvs'];

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import { traceVerbose } from '../../../../common/logger';+import { chain, iterable } from '../../../../common/utils/async';+import {+    getEnvironmentVariable, getUserHomeDir,+} from '../../../../common/utils/platform';+import {+    PythonEnvInfo, PythonEnvKind, UNKNOWN_PYTHON_VERSION,+} from '../../../base/info';+import { buildEnvInfo } from '../../../base/info/env';+import { ILocator, IPythonEnvsIterator } from '../../../base/locator';+import { PythonEnvsWatcher } from '../../../base/watcher';+import { findInterpretersInDir } from '../../../common/commonUtils';+import { getFileInfo, pathExists } from '../../../common/externalDependencies';+import { isVenvEnvironment, isVirtualenvEnvironment, isVirtualenvwrapperEnvironment } from './virtualEnvironmentIdentifier';++const DEFAULT_SEARCH_DEPTH = 2;++/**+ * Gets all default virtual environment locations. This uses WORKON_HOME,+ * and user home directory to find some known locations where global virtual+ * environments are often created.+ */+async function getGlobalVirtualEnvDirs(): Promise<string[]> {+    const venvDirs:string[] = [];++    const workOnHome = getEnvironmentVariable('WORKON_HOME');+    if (workOnHome && await pathExists(workOnHome)) {+        venvDirs.push(workOnHome);+    }++    const homeDir = getUserHomeDir();+    if (homeDir && await pathExists(homeDir)) {+        const subDirs = ['Envs', 'envs', '.direnv', '.venvs', '.virtualenvs'];

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import {+    getEnvironmentVariable, getOSType, getUserHomeDir, OSType,+} from '../../../../common/utils/platform';+import { pathExists } from '../../../common/externalDependencies';++/**+ * Checks if the given interpreter belongs to a venv based environment.+ * @param {string} interpreterPath: Absolute path to the python interpreter.+ * @returns {boolean} : Returns true if the interpreter belongs to a venv environment.+ */+export async function isVenvEnvironment(interpreterPath:string): Promise<boolean> {+    const pyvenvConfigFile = 'pyvenv.cfg';++    // Check if the pyvenv.cfg file is in the directory as the interpreter.+    // env+    // |__ pyvenv.cfg  <--- check if this file exists+    // |__ python  <--- interpreterPath+    const venvPath1 = path.join(path.dirname(interpreterPath), pyvenvConfigFile);++    // Check if the pyvenv.cfg file is in the parent directory relative to the interpreter.+    // env+    // |__ pyvenv.cfg  <--- check if this file exists+    // |__ bin or Scripts+    //     |__ python  <--- interpreterPath+    const venvPath2 = path.join(path.dirname(path.dirname(interpreterPath)), pyvenvConfigFile);++    return [await pathExists(venvPath1), await pathExists(venvPath2)].includes(true);+}++/**+ * Checks if the given interpreter belongs to a virtualenv based environment.+ * @param {string} interpreterPath: Absolute path to the python interpreter.+ * @returns {boolean} : Returns true if the interpreter belongs to a virtualenv environment.+ */+export async function isVirtualenvEnvironment(interpreterPath:string): Promise<boolean> {+    // Check if there are any activate.* files in the same directory as the interpreter.+    //+    // env+    // |__ activate, activate.*  <--- check if any of these files exist+    // |__ python  <--- interpreterPath+    const directory = path.dirname(interpreterPath);+    const files = await fsapi.readdir(directory);+    const regex = /^activate(\.([A-z]|\d)+)?$/;

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import {+    getEnvironmentVariable, getOSType, getUserHomeDir, OSType,+} from '../../../../common/utils/platform';+import { pathExists } from '../../../common/externalDependencies';++/**+ * Checks if the given interpreter belongs to a venv based environment.+ * @param {string} interpreterPath: Absolute path to the python interpreter.+ * @returns {boolean} : Returns true if the interpreter belongs to a venv environment.+ */+export async function isVenvEnvironment(interpreterPath:string): Promise<boolean> {+    const pyvenvConfigFile = 'pyvenv.cfg';++    // Check if the pyvenv.cfg file is in the directory as the interpreter.+    // env+    // |__ pyvenv.cfg  <--- check if this file exists+    // |__ python  <--- interpreterPath+    const venvPath1 = path.join(path.dirname(interpreterPath), pyvenvConfigFile);++    // Check if the pyvenv.cfg file is in the parent directory relative to the interpreter.+    // env+    // |__ pyvenv.cfg  <--- check if this file exists+    // |__ bin or Scripts+    //     |__ python  <--- interpreterPath+    const venvPath2 = path.join(path.dirname(path.dirname(interpreterPath)), pyvenvConfigFile);++    return [await pathExists(venvPath1), await pathExists(venvPath2)].includes(true);

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as path from 'path';+import { traceError, traceVerbose } from '../../../../common/logger';+import { chain, iterable } from '../../../../common/utils/async';+import {+    Architecture, getEnvironmentVariable, getUserHomeDir,+} from '../../../../common/utils/platform';+import {+    PythonEnvInfo, PythonEnvKind, PythonVersion, UNKNOWN_PYTHON_VERSION,+} from '../../../base/info';+import { parseVersion } from '../../../base/info/pythonVersion';+import { ILocator, IPythonEnvsIterator } from '../../../base/locator';+import { PythonEnvsWatcher } from '../../../base/watcher';+import { findInterpretersInDir } from '../../../common/commonUtils';+import { getFileInfo, pathExists } from '../../../common/externalDependencies';+import { isVenvEnvironment, isVirtualenvEnvironment, isVirtualenvwrapperEnvironment } from './virtualEnvironmentIdentifier';++const DEFAULT_SEARCH_DEPTH = 4;++/**+ * Gets all default virtual environment locations. This uses WORKON_HOME,+ * and user home directory to find some known locations where global virtual+ * environments are often created.+ */+async function getGlobalVirtualEnvDirs(): Promise<string[]> {+    const venvDirs:string[] = [];+    const dirPaths:string[] = [];++    const workOnHome = getEnvironmentVariable('WORKON_HOME');+    if (workOnHome) {+        dirPaths.push(workOnHome);+    }++    const homeDir = getUserHomeDir();+    if (homeDir) {+        dirPaths.push(path.join(homeDir, 'envs'));+        dirPaths.push(path.join(homeDir, '.direnv'));+        dirPaths.push(path.join(homeDir, '.venvs'));+        dirPaths.push(path.join(homeDir, '.virtualenvs'));+        dirPaths.push(path.join(homeDir, '.local', 'share', 'virtualenvs'));+    }++    const exists = await Promise.all(dirPaths.map(pathExists));+    exists.forEach((v, i) => {+        if (v) {+            venvDirs.push(dirPaths[i]);+        }+    });++    return venvDirs;+}++/**+ * Gets the virtual environment kind for a given interpreter path.+ * This only checks for environments created using venv, virtualenv,+ * and virtualenvwrapper based environments.+ * @param interpreterPath: Absolute path to the interpreter paths.+ */+async function getVirtualEnvKind(interpreterPath:string): Promise<PythonEnvKind> {+    if (await isVenvEnvironment(interpreterPath)) {+        return PythonEnvKind.Venv;+    }++    if (await isVirtualenvwrapperEnvironment(interpreterPath)) {+        return PythonEnvKind.VirtualEnvWrapper;+    }++    if (await isVirtualenvEnvironment(interpreterPath)) {+        return PythonEnvKind.VirtualEnv;+    }++    return PythonEnvKind.Unknown;+}++/**+ * Takes absolute path to the interpreter and environment kind to build+ * environment info.+ * @param {string} interpreterPath: Absolute path to interpreter.+ * @param {PythonEnvKind} kind: Kind for the given environment.+ */+async function buildEnvInfo(interpreterPath:string, kind:PythonEnvKind): Promise<PythonEnvInfo> {+    let version:PythonVersion;+    try {+        version = parseVersion(path.basename(interpreterPath));+    } catch (ex) {+        traceError(`Failed to parse version from path: ${interpreterPath}`, ex);+        version = UNKNOWN_PYTHON_VERSION;+    }+    return {+        name: '',+        location: '',+        kind,+        executable: {+            filename: interpreterPath,+            sysPrefix: '',+            ...(await getFileInfo(interpreterPath)),+        },+        version,+        arch: Architecture.Unknown,+        distro: { org: '' },+    };+}++/**+ * Finds and resolves virtual environments created in known global locations.+ */+export class GlobalVirtualEnvironmentLocator extends PythonEnvsWatcher implements ILocator {+    private virtualEnvKinds = [+        PythonEnvKind.Venv,+        PythonEnvKind.VirtualEnv,+        PythonEnvKind.VirtualEnvWrapper,+    ];++    public constructor(private readonly searchDepth?:number) {+        super();+    }++    public iterEnvs(): IPythonEnvsIterator {+        // Number of levels of sub-directories to recurse when looking for+        // interpreters+        const searchDepth = this.searchDepth ?? DEFAULT_SEARCH_DEPTH;++        async function* iterator(virtualEnvKinds:PythonEnvKind[]) {+            const envRootDirs = await getGlobalVirtualEnvDirs();+            const envGenerators = envRootDirs.map((envRootDir) => {+                async function* generator() {+                    traceVerbose(`Searching for global virtual envs in: ${envRootDir}`);++                    const envGenerator = findInterpretersInDir(envRootDir, searchDepth);++                    for await (const env of envGenerator) {+                    // We only care about python.exe (on windows) and python (on linux/mac)+                    // Other version like python3.exe or python3.8 are often symlinks to+                    // python.exe or python in the same directory in the case od virtual

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as path from 'path';+import { traceError, traceVerbose } from '../../../../common/logger';+import { chain, iterable } from '../../../../common/utils/async';+import {+    Architecture, getEnvironmentVariable, getUserHomeDir,+} from '../../../../common/utils/platform';+import {+    PythonEnvInfo, PythonEnvKind, PythonVersion, UNKNOWN_PYTHON_VERSION,+} from '../../../base/info';+import { parseVersion } from '../../../base/info/pythonVersion';+import { ILocator, IPythonEnvsIterator } from '../../../base/locator';+import { PythonEnvsWatcher } from '../../../base/watcher';+import { findInterpretersInDir } from '../../../common/commonUtils';+import { getFileInfo, pathExists } from '../../../common/externalDependencies';+import { isVenvEnvironment, isVirtualenvEnvironment, isVirtualenvwrapperEnvironment } from './virtualEnvironmentIdentifier';++const DEFAULT_SEARCH_DEPTH = 4;++/**+ * Gets all default virtual environment locations. This uses WORKON_HOME,+ * and user home directory to find some known locations where global virtual+ * environments are often created.+ */+async function getGlobalVirtualEnvDirs(): Promise<string[]> {+    const venvDirs:string[] = [];+    const dirPaths:string[] = [];++    const workOnHome = getEnvironmentVariable('WORKON_HOME');+    if (workOnHome) {+        dirPaths.push(workOnHome);+    }++    const homeDir = getUserHomeDir();+    if (homeDir) {+        dirPaths.push(path.join(homeDir, 'envs'));+        dirPaths.push(path.join(homeDir, '.direnv'));+        dirPaths.push(path.join(homeDir, '.venvs'));+        dirPaths.push(path.join(homeDir, '.virtualenvs'));+        dirPaths.push(path.join(homeDir, '.local', 'share', 'virtualenvs'));+    }++    const exists = await Promise.all(dirPaths.map(pathExists));+    exists.forEach((v, i) => {+        if (v) {+            venvDirs.push(dirPaths[i]);+        }+    });++    return venvDirs;+}++/**+ * Gets the virtual environment kind for a given interpreter path.+ * This only checks for environments created using venv, virtualenv,+ * and virtualenvwrapper based environments.+ * @param interpreterPath: Absolute path to the interpreter paths.+ */+async function getVirtualEnvKind(interpreterPath:string): Promise<PythonEnvKind> {+    if (await isVenvEnvironment(interpreterPath)) {+        return PythonEnvKind.Venv;+    }++    if (await isVirtualenvwrapperEnvironment(interpreterPath)) {+        return PythonEnvKind.VirtualEnvWrapper;+    }++    if (await isVirtualenvEnvironment(interpreterPath)) {+        return PythonEnvKind.VirtualEnv;+    }++    return PythonEnvKind.Unknown;+}++/**+ * Takes absolute path to the interpreter and environment kind to build+ * environment info.+ * @param {string} interpreterPath: Absolute path to interpreter.+ * @param {PythonEnvKind} kind: Kind for the given environment.+ */+async function buildEnvInfo(interpreterPath:string, kind:PythonEnvKind): Promise<PythonEnvInfo> {+    let version:PythonVersion;+    try {+        version = parseVersion(path.basename(interpreterPath));+    } catch (ex) {+        traceError(`Failed to parse version from path: ${interpreterPath}`, ex);+        version = UNKNOWN_PYTHON_VERSION;+    }+    return {+        name: '',+        location: '',+        kind,+        executable: {+            filename: interpreterPath,+            sysPrefix: '',+            ...(await getFileInfo(interpreterPath)),+        },+        version,+        arch: Architecture.Unknown,+        distro: { org: '' },+    };+}++/**+ * Finds and resolves virtual environments created in known global locations.+ */+export class GlobalVirtualEnvironmentLocator extends PythonEnvsWatcher implements ILocator {+    private virtualEnvKinds = [+        PythonEnvKind.Venv,+        PythonEnvKind.VirtualEnv,+        PythonEnvKind.VirtualEnvWrapper,+    ];++    public constructor(private readonly searchDepth?:number) {+        super();+    }++    public iterEnvs(): IPythonEnvsIterator {+        // Number of levels of sub-directories to recurse when looking for+        // interpreters+        const searchDepth = this.searchDepth ?? DEFAULT_SEARCH_DEPTH;++        async function* iterator(virtualEnvKinds:PythonEnvKind[]) {+            const envRootDirs = await getGlobalVirtualEnvDirs();+            const envGenerators = envRootDirs.map((envRootDir) => {+                async function* generator() {+                    traceVerbose(`Searching for global virtual envs in: ${envRootDir}`);++                    const envGenerator = findInterpretersInDir(envRootDir, searchDepth);++                    for await (const env of envGenerator) {+                    // We only care about python.exe (on windows) and python (on linux/mac)+                    // Other version like python3.exe or python3.8 are often symlinks to+                    // python.exe or python in the same directory in the case od virtual+                    // environments.+                        const name = path.basename(env).toLowerCase();+                        if (name === 'python.exe' || name === 'python') {+                        // We should extract the kind here to avoid doing is*Environment()+                        // check multiple times. Those checks are file system heavy and+                        // we can use the kind to determine this anyway.

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import { chain, iterable } from '../../common/utils/async';+import { getOSType, OSType } from '../../common/utils/platform';+import { isPosixPythonBin } from './posixUtils';+import { isWindowsPythonExe } from './windowsUtils';++export async function* findInterpretersInDir(root:string, recurseLevels?:number): AsyncIterableIterator<string> {+    const dirContents = (await fsapi.readdir(root)).map((c) => path.join(root, c));+    const os = getOSType();+    const generators = dirContents.map((item) => {+        async function* generator() {+            const stat = await fsapi.lstat(item);++            if (stat.isDirectory()) {+                if (recurseLevels && recurseLevels > 0) {+                    const subItems = findInterpretersInDir(item, recurseLevels - 1);++                    for await (const subItem of subItems) {+                        yield subItem;+                    }+                }+            } else if (+                (os === OSType.Windows && isWindowsPythonExe(item))+                || (os !== OSType.Windows && isPosixPythonBin(item))

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import { HKCU, HKLM } from 'winreg';+import { getInterpreterDataFromRegistry, IRegistryInterpreterData } from '../../../common/windowsUtils';++export async function getRegistryInterpreters() : Promise<IRegistryInterpreterData[]> {+    let registryData:IRegistryInterpreterData[] = [];++    // Read from PythonCore locations+    for (const arch of ['x64', 'x86']) {+        for (const hive of [HKLM, HKCU]) {+            registryData = registryData.concat(await getInterpreterDataFromRegistry({ arch, hive, key: '\\SOFTWARE\\Python\\PythonCore' }));+        }+    }++    // Read from PythonCodingPack locations+    return registryData.concat(await getInterpreterDataFromRegistry({ arch: 'x64', hive: HKCU, key: '\\SOFTWARE\\Python\\PythonCodingPack' }));+}

 export class DebuggerVariables implements IConditionalJupyterVariables, DebugAda             ? this.configService.getSettings().datascience.variableExplorerExclude?.split(';')             : []; -        const allowedVariables = variablesResponse.body.variables.filter((v) => {-            if (!v.name || !v.type || !v.value) {-                return false;-            }-            if (exclusionList && exclusionList.includes(v.type)) {-                return false;-            }-            if (v.name.startsWith('_')) {-                return false;-            }-            if (KnownExcludedVariables.has(v.name)) {-                return false;-            }-            if (v.type === 'NoneType') {-                return false;-            }-            return true;-        });+        const allowedVariables = variablesResponse.body.variables

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import { getPathEnvironmentVariable } from '../../common/utils/platform';++/**+ * Checks if a given path ends with python*.exe+ * @param {string} interpreterPath : Path to python interpreter.+ * @returns {boolean} : Returns true if the path matches pattern for windows python executable.+ */+export function isPosixPythonBin(interpreterPath:string): boolean {+    /**+     * This Reg-ex matches following file names:+     * python+     * python3+     * python38+     * python3.8+     */+    const posixPythonBinPattern = /^python(\d+(.\d+)?)?$/;++    return posixPythonBinPattern.test(path.basename(interpreterPath));+}++export async function commonPosixBinPaths(): Promise<string[]> {+    const searchPaths = (getPathEnvironmentVariable() || '')+        .split(path.delimiter)+        .filter((p) => p.length > 0);++    const paths: Set<string> = new Set(+        [+            '/bin',+            '/etc',+            '/lib',+            '/lib/x86_64-linux-gnu',+            '/lib64',+            '/sbin',+            '/snap/bin',+            '/usr/bin',+            '/usr/games',+            '/usr/include',+            '/usr/lib',+            '/usr/lib/x86_64-linux-gnu',+            '/usr/lib64',+            '/usr/libexec',+            '/usr/local',+            '/usr/local/bin',+            '/usr/local/etc',+            '/usr/local/games',+            '/usr/local/lib',+            '/usr/local/sbin',+            '/usr/sbin',+            '/usr/share',+            '~/.local/bin',+        ].concat(searchPaths),

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import { getPathEnvironmentVariable } from '../../common/utils/platform';++/**+ * Checks if a given path ends with python*.exe+ * @param {string} interpreterPath : Path to python interpreter.+ * @returns {boolean} : Returns true if the path matches pattern for windows python executable.+ */+export function isPosixPythonBin(interpreterPath:string): boolean {+    /**+     * This Reg-ex matches following file names:+     * python+     * python3+     * python38+     * python3.8+     */+    const posixPythonBinPattern = /^python(\d+(.\d+)?)?$/;++    return posixPythonBinPattern.test(path.basename(interpreterPath));+}++export async function commonPosixBinPaths(): Promise<string[]> {+    const searchPaths = (getPathEnvironmentVariable() || '')+        .split(path.delimiter)+        .filter((p) => p.length > 0);++    const paths: Set<string> = new Set(+        [+            '/bin',+            '/etc',+            '/lib',+            '/lib/x86_64-linux-gnu',+            '/lib64',+            '/sbin',+            '/snap/bin',+            '/usr/bin',+            '/usr/games',+            '/usr/include',+            '/usr/lib',+            '/usr/lib/x86_64-linux-gnu',+            '/usr/lib64',+            '/usr/libexec',+            '/usr/local',+            '/usr/local/bin',+            '/usr/local/etc',+            '/usr/local/games',+            '/usr/local/lib',+            '/usr/local/sbin',+            '/usr/sbin',+            '/usr/share',+            '~/.local/bin',+        ].concat(searchPaths),

+// Copyright (c) Microsoft Corporation. All rights reserved.+// Licensed under the MIT License.++import * as fsapi from 'fs-extra';+import * as path from 'path';+import { traceVerbose } from '../../../../common/logger';++import { Architecture } from '../../../../common/utils/platform';+import {+    PythonEnvInfo, PythonEnvKind, PythonReleaseLevel, PythonVersion,+} from '../../../base/info';+import { parseVersion } from '../../../base/info/pythonVersion';+import { ILocator, IPythonEnvsIterator } from '../../../base/locator';+import { PythonEnvsWatcher } from '../../../base/watcher';+import { getFileInfo, resolveSymbolicLink } from '../../../common/commonUtils';+import { commonPosixBinPaths, isPosixPythonBin } from '../../../common/posixUtils';++async function getPythonBinFromKnownPaths(): Promise<string[]> {+    const knownPaths = await commonPosixBinPaths();+    const pythonBins:Set<string> = new Set();+    // eslint-disable-next-line no-restricted-syntax+    for (const knownPath of knownPaths) {+        // eslint-disable-next-line no-await-in-loop+        const files = (await fsapi.readdir(knownPath))+            .map((filename:string) => path.join(knownPath, filename))+            .filter(isPosixPythonBin);++        // eslint-disable-next-line no-restricted-syntax+        for (const file of files) {+            // Ensure that we have a collection of unique global binaries by+            // resolving all symlinks to the target binaries.+            // eslint-disable-next-line no-await-in-loop+            const resolvedBin = await resolveSymbolicLink(file);+            pythonBins.add(resolvedBin);+            traceVerbose(`Found: ${file} --> ${resolvedBin}`);+        }+    }++    return Array.from(pythonBins);+}++export class PosixKnownPathsLocator extends PythonEnvsWatcher implements ILocator {+    private kind: PythonEnvKind = PythonEnvKind.OtherGlobal;++    public iterEnvs(): IPythonEnvsIterator {+        const buildEnvInfo = (bin:string) => this.buildEnvInfo(bin);+        const iterator = async function* () {+            const exes = await getPythonBinFromKnownPaths();+            yield* exes.map(buildEnvInfo);+        };+        return iterator();+    }++    public resolveEnv(env: string | PythonEnvInfo): Promise<PythonEnvInfo | undefined> {+        const executablePath = typeof env === 'string' ? env : env.executable.filename;+        return this.buildEnvInfo(executablePath);+    }++    private async buildEnvInfo(bin:string): Promise<PythonEnvInfo> {+        let version:PythonVersion;+        try {+            version = parseVersion(path.basename(bin));+        } catch (e) {