pyflyby 1.8.9__tar.gz → 1.9.1__tar.gz

{pyflyby-1.8.9/lib/python/pyflyby.egg-info → pyflyby-1.9.1}/PKG-INFO

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

{pyflyby-1.8.9 → pyflyby-1.9.1}/bin/pyflyby/_autoimp.py

@@ -5,11 +5,10 @@
 
 
 import ast
+import builtins
 import contextlib
 import copy
-import six
-from   six                      import exec_, reraise
-from   six.moves                import builtins
+from   six                      import reraise
 import sys
 import types
 
@@ -23,8 +22,22 @@ from   pyflyby._importdb        import ImportDB
 from   pyflyby._importstmt      import Import
 from   pyflyby._log             import logger
 from   pyflyby._modules         import ModuleHandle
-from   pyflyby._parse           import PythonBlock, infer_compile_mode
+from   pyflyby._parse           import PythonBlock, infer_compile_mode, _is_ast_str
 
+if sys.version_info >= (3, 12):
+    ATTRIBUTE_NAME = "value"
+else:
+    ATTRIBUTE_NAME = "s"
+
+if sys.version_info > (3, 11):
+    LOAD_SHIFT = 1
+else:
+    LOAD_SHIFT = 0
+
+if sys.version_info > (3, 11):
+    LOAD_SHIFT = 1
+else:
+    LOAD_SHIFT = 0
 
 NoneType = type(None)
 EllipsisType = type(Ellipsis)
@@ -441,7 +454,8 @@ class _MissingImportFinder(object):
             literal_brace_identifiers = set(
                 iden
                 for f in codeblock.string_literals()
-                for iden in brace_identifiers(f.s))
+                for iden in brace_identifiers(getattr(f, ATTRIBUTE_NAME))
+            )
             if literal_brace_identifiers:
                 for ident in literal_brace_identifiers:
                     try:
@@ -450,6 +464,7 @@ class _MissingImportFinder(object):
                         continue
                     symbol_needs_import(ident, self.scopestack)
         self._scan_unused_imports()
+        logger.debug("missing: %s, unused: %s", missing_imports, self.unused_imports)
         return missing_imports, self.unused_imports
 
     def visit(self, node):
@@ -498,11 +513,11 @@ class _MissingImportFinder(object):
                     self.visit(value)
                 else:
                     raise TypeError(
-                        "unexpected %s" %
-                        (', '.join(type(v).__name__ for v in value)))
-            elif isinstance(value, (six.integer_types, float, complex,
-                                    str, six.text_type, NoneType, bytes,
-                                    EllipsisType)):
+                        "unexpected %s" % (", ".join(type(v).__name__ for v in value))
+                    )
+            elif isinstance(
+                value, (int, float, complex, str, NoneType, bytes, EllipsisType)
+            ):
                 pass
             else:
                 raise TypeError(
@@ -570,7 +585,7 @@ class _MissingImportFinder(object):
             if not isinstance(node.value, ast.List):
                 logger.warning("Don't know how to handle __all__ as (%s)" % node.value)
                 return
-            if not all(isinstance(e, ast.Str) for e in node.value.elts):
+            if not all(_is_ast_str(e) for e in node.value.elts):
                 logger.warning("Don't know how to handle __all__ with list elements other than str")
                 return
             for e in node.value.elts:
@@ -578,7 +593,11 @@ class _MissingImportFinder(object):
 
     def visit_ClassDef(self, node):
         logger.debug("visit_ClassDef(%r)", node)
-        assert node._fields == ('name', 'bases', 'keywords', 'body', 'decorator_list')
+        if sys.version_info > (3,12):
+            # we don't visit type_params, so autoimport won't work yet for type annotations
+            assert node._fields == ('name', 'bases', 'keywords', 'body', 'decorator_list', 'type_params'), node._fields
+        else:
+            assert node._fields == ('name', 'bases', 'keywords', 'body', 'decorator_list'), node._fields
         self.visit(node.bases)
         self.visit(node.decorator_list)
         # The class's name is only visible to others (not to the body to the
@@ -609,10 +628,14 @@ class _MissingImportFinder(object):
         #     scope.
         #   - Store the name in the current scope (but not visibly to
         #     args/decorator_list).
-        assert node._fields == ('name', 'args', 'body', 'decorator_list', 'returns', 'type_comment'), node._fields
+        if sys.version_info > (3, 12):
+            # we don't visit type_params, so autoimport won't work yet for type annotations
+            assert node._fields ==  ('name', 'args', 'body', 'decorator_list', 'returns', 'type_comment', 'type_params'), node._fields
+        else:
+            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)
+            self.visit(node.args)
             if node.returns:
                 self.visit(node.returns)
             self._visit_typecomment(node.type_comment)
@@ -872,6 +895,7 @@ class _MissingImportFinder(object):
             # record it as unused.
             oldvalue = scope.get(fullname)
             if isinstance(oldvalue, _UseChecker) and not oldvalue.used:
+                logger.debug("Adding to unused %s", oldvalue)
                 self.unused_imports.append((oldvalue.lineno, oldvalue.source))
         scope[fullname] = value
 
@@ -1002,11 +1026,12 @@ class _MissingImportFinder(object):
         if unused_imports is None:
             return
         scope = self.scopestack[-1]
-        for name, value in six.iteritems(scope):
+        for name, value in scope.items():
             if not isinstance(value, _UseChecker):
                 continue
             if value.used:
                 continue
+            logger.debug("Also Adding to usunsed import: %s ", value)
             unused_imports.append(( value.lineno, value.source ))
         unused_imports.sort()
 
@@ -1128,13 +1153,19 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
             % (type(co).__name__,))
     # Initialize local constants for fast access.
     from opcode import HAVE_ARGUMENT, EXTENDED_ARG, opmap
+
     LOAD_ATTR    = opmap['LOAD_ATTR']
-    LOAD_METHOD = opmap['LOAD_METHOD']
+    LOAD_METHOD  = opmap['LOAD_METHOD']
     LOAD_GLOBAL  = opmap['LOAD_GLOBAL']
     LOAD_NAME    = opmap['LOAD_NAME']
     STORE_ATTR   = opmap['STORE_ATTR']
     STORE_GLOBAL = opmap['STORE_GLOBAL']
     STORE_NAME   = opmap['STORE_NAME']
+
+    if sys.version_info > (3, 11):
+        CACHE = opmap["CACHE"]
+    else:
+        CACHE = object()
     # Keep track of the partial name so far that started with a LOAD_GLOBAL.
     # If ``pending`` is not None, then it is a list representing the name
     # components we've seen so far.
@@ -1227,6 +1258,8 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
         c = bytecode[i]
         op = _op(c)
         i += 1
+        if op == CACHE:
+            continue
         if op >= HAVE_ARGUMENT:
             oparg = bytecode[i] | extended_arg
             extended_arg = 0
@@ -1258,7 +1291,13 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
                 loads_before_label_without_stores.add(fullname)
             # Fall through.
 
-        if op in [LOAD_GLOBAL, LOAD_NAME]:
+        if op is LOAD_GLOBAL:
+            # Starting with 3.11, the low bit is used to tell whether to
+            # push an extra null on the stack, so we need to >> 1
+            # >> 0 does nothing
+            pending = [co.co_names[oparg >> LOAD_SHIFT]]
+            continue
+        if op is LOAD_NAME:
             pending = [co.co_names[oparg]]
             continue
 
@@ -1489,7 +1528,7 @@ def find_missing_imports(arg, namespaces):
       ``list`` of ``DottedIdentifier``
     """
     namespaces = ScopeStack(namespaces)
-    if isinstance(arg, (DottedIdentifier, six.string_types)):
+    if isinstance(arg, (DottedIdentifier, str)):
         try:
             arg = DottedIdentifier(arg)
         except BadDottedIdentifierError:
@@ -1626,7 +1665,7 @@ def _try_import(imp, namespace):
     # then (3) copy into the user's namespace if it didn't already exist.
     scratch_namespace = {}
     try:
-        exec_(stmt, scratch_namespace)
+        exec(stmt, scratch_namespace)
         imported = scratch_namespace[name0]
     except Exception as e:
         logger.warning("Error attempting to %r: %s: %s", stmt, type(e).__name__, e,
@@ -1897,7 +1936,7 @@ def auto_eval(arg, filename=None, mode=None,
     """
     if isinstance(flags, int):
         assert isinstance(flags, CompilerFlags)
-    if isinstance(arg, (six.string_types, Filename, FileText, PythonBlock)):
+    if isinstance(arg, (str, Filename, FileText, PythonBlock)):
         block = PythonBlock(arg, filename=filename, flags=flags,
                             auto_flags=auto_flags)
         flags = block.flags

{pyflyby-1.8.9 → pyflyby-1.9.1}/bin/pyflyby/_comms.py

@@ -4,7 +4,8 @@ from __future__ import print_function
 from   pyflyby._imports2s       import (SourceToSourceFileImportsTransformation,
                                         SourceToSourceImportBlockTransformation,
                                         fix_unused_and_missing_imports,
-                                        replace_star_imports)
+                                        replace_star_imports,
+                                        reformat_import_statements)
 from   pyflyby._importstmt      import Import
 from   pyflyby._log             import logger
 import six
@@ -92,8 +93,6 @@ def comm_close_handler(comm, message):
 
 
 def _reformat_helper(input_code, imports):
-    from pyflyby._imports2s import reformat_import_statements
-
     if PYFLYBY_START_MSG in input_code:
         before, bmarker, middle = input_code.partition(PYFLYBY_START_MSG)
     else:
@@ -131,8 +130,8 @@ def extract_import_statements(text):
         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])
+    imports = '\n'.join([str(im.pretty_print()).strip() for im in transformer.import_blocks])
+    remaining_code = "\n".join([str(st.pretty_print()).strip() 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):
@@ -141,16 +140,18 @@ def collect_code_with_imports_on_top(imports: str, cell_array):
         + "\n"
         + "\n".join(
             [
-                cell["text"] if cell["type"] == "code" else ""
+                cell["text"] if cell["type"] == "code" and not cell.get("ignore", False) else ""
                 for cell in cell_array
             ]
         )
     )
 
 def run_tidy_imports(code):
-   return str(
-        fix_unused_and_missing_imports(
-            replace_star_imports(code)
+    return str(
+        reformat_import_statements(
+            fix_unused_and_missing_imports(
+                replace_star_imports(code)
+            )
         )
     )
 
@@ -192,12 +193,20 @@ def comm_open_handler(comm, message):
             # while clubbing similar imports and re-ordering them.
             import_statements, processed_cell_array = "", []
             for cell in cell_array:
+                ignore = False
                 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})
+                    try:
+                        imports, text = extract_import_statements(text)
+                        import_statements += (imports + "\n")
+                    except SyntaxError:
+                        # If a cell triggers Syntax Error, we set ignore to
+                        # True and don't include it when running tidy-imports
+                        # For eg. this is triggered due to cells with magic
+                        # commands
+                        ignore = True
+                processed_cell_array.append({"text": text, "type": cell_type, "ignore": ignore})
             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)

{pyflyby-1.8.9 → pyflyby-1.9.1}/bin/pyflyby/_dbg.py

@@ -3,7 +3,7 @@
 # License: MIT http://opensource.org/licenses/MIT
 
 
-
+import builtins
 from   contextlib               import contextmanager
 import errno
 from   functools                import wraps
@@ -14,9 +14,6 @@ import sys
 import time
 from   types                    import CodeType, FrameType, TracebackType
 
-import six
-from   six.moves                import builtins
-
 from   collections.abc          import Callable
 
 from   pyflyby._file            import Filename
@@ -349,7 +346,8 @@ def _debug_code(arg, globals=None, locals=None, auto_import=True, tty="/dev/tty"
         print("Entering debugger.  Use 'n' to step, 'c' to run, 'q' to stop.")
         print("")
         from ._parse import PythonStatement, PythonBlock, FileText
-        if isinstance(arg, (six.string_types, PythonStatement, PythonBlock, FileText)):
+
+        if isinstance(arg, (str, PythonStatement, PythonBlock, FileText)):
             # Compile the block so that we can get the right compile mode.
             arg = PythonBlock(arg)
             # TODO: enter text into linecache
@@ -502,8 +500,9 @@ def debugger(*args, **kwargs):
             # TODO: capture globals/locals when relevant.
             wait_for_debugger_to_attach(arg)
             return
-    if isinstance(arg, (six.string_types, PythonStatement, PythonBlock, FileText,
-                        CodeType, Callable)):
+    if isinstance(
+        arg, (str, PythonStatement, PythonBlock, FileText, CodeType, Callable)
+    ):
         _debug_code(arg, globals=globals, locals=locals, tty=tty)
         on_continue()
         return
@@ -1013,12 +1012,12 @@ def inject(pid, statements, wait=True, show_gdb_output=False):
     """
     import subprocess
     os.kill(pid, 0) # raises OSError "No such process" unless pid exists
-    if isinstance(statements, six.string_types):
+    if isinstance(statements, str):
         statements = (statements,)
     else:
         statements = tuple(statements)
     for statement in statements:
-        if not isinstance(statement, six.string_types):
+        if not isinstance(statement, str):
             raise TypeError(
                 "Expected iterable of strings, not %r" % (type(statement),))
     # Based on

{pyflyby-1.8.9/lib/python → pyflyby-1.9.1/bin}/pyflyby/_docxref.py

@@ -26,8 +26,7 @@
 
 
 import re
-import six
-from   six.moves                import builtins
+import builtins
 from   textwrap                 import dedent
 
 from   epydoc.apidoc            import (ClassDoc, ModuleDoc, PropertyDoc,
@@ -348,7 +347,7 @@ class XrefScanner(object):
             return ''
 
         def scan_tree(tree):
-            if isinstance(tree, six.string_types):
+            if isinstance(tree, str):
                 return tree
             variables = [scan_tree(child) for child in tree.children]
             if tree.tag == 'link':

{pyflyby-1.8.9 → pyflyby-1.9.1}/bin/pyflyby/_file.py

@@ -8,11 +8,8 @@ from   functools                import total_ordering
 import io
 import os
 import re
-import six
 import sys
 
-from   six                      import string_types
-
 from   pyflyby._util            import cached_attribute, cmp, memoize
 
 
@@ -34,13 +31,13 @@ class Filename(object):
     def __new__(cls, arg):
         if isinstance(arg, cls):
             return arg
-        if isinstance(arg, six.string_types):
+        if isinstance(arg, str):
             return cls._from_filename(arg)
         raise TypeError
 
     @classmethod
     def _from_filename(cls, filename):
-        if not isinstance(filename, six.string_types):
+        if not isinstance(filename, str):
             raise TypeError
         filename = str(filename)
         if not filename:
@@ -336,7 +333,7 @@ FilePos._ONE_ONE = FilePos._from_lc(1, 1)
 
 
 @total_ordering
-class FileText(object):
+class FileText:
     """
     Represents a contiguous sequence of lines from a file.
     """
@@ -372,7 +369,7 @@ class FileText(object):
             return cls(read_file(arg), filename=filename, startpos=startpos)
         elif hasattr(arg, "__text__"):
             return FileText(arg.__text__(), filename=filename, startpos=startpos)
-        elif isinstance(arg, six.string_types):
+        elif isinstance(arg, str):
             self = object.__new__(cls)
             self.joined = arg
         else:
@@ -389,7 +386,7 @@ class FileText(object):
     def _from_lines(cls, lines, filename, startpos):
         assert type(lines) is tuple
         assert len(lines) > 0
-        assert isinstance(lines[0], string_types)
+        assert isinstance(lines[0], str)
         assert not lines[-1].endswith("\n")
         self = object.__new__(cls)
         self.lines    = lines

{pyflyby-1.8.9/lib/python → pyflyby-1.9.1/bin}/pyflyby/_flags.py

@@ -7,11 +7,11 @@
 import __future__
 import ast
 import operator
-import six
 from   six.moves                import reduce
 import warnings
 
 from   pyflyby._util            import cached_attribute
+from typing import Tuple
 
 # Initialize mappings from compiler_flag to feature name and vice versa.
 _FLAG2NAME = {}
@@ -49,6 +49,10 @@ class CompilerFlags(int):
 
     """
 
+    # technically both those are compiler flags, but we can't use Self. May need typing_extensions ?
+    _ZERO:int
+    _UNKNOWN: int
+
     def __new__(cls, *args):
         """
         Construct a new ``CompilerFlags`` instance.
@@ -72,7 +76,7 @@ class CompilerFlags(int):
                 ' flags values change between Python versions. If you are sure use .from_int',
                 DeprecationWarning, stacklevel=2)
                 return cls.from_int(arg)
-            elif isinstance(arg, six.string_types):
+            elif isinstance(arg, str):
                 return cls.from_str(arg)
             elif isinstance(arg, ast.AST):
                 return cls.from_ast(arg)
@@ -100,7 +104,7 @@ class CompilerFlags(int):
                     raise ValueError
 
             #assert flags == [0x10000, 0x8000], flags
-                
+
             return cls.from_int(reduce(operator.or_, flags))
 
     @classmethod
@@ -117,7 +121,7 @@ class CompilerFlags(int):
         return self
 
     @classmethod
-    def from_str(cls, arg):
+    def from_str(cls, arg:str):
         try:
             flag = _NAME2FLAG[arg]
         except KeyError:
@@ -153,7 +157,7 @@ class CompilerFlags(int):
         return cls(flags)
 
     @cached_attribute
-    def names(self):
+    def names(self) -> Tuple[str]:
         return tuple(
             n
             for f, n in _FLAGNAME_ITEMS

{pyflyby-1.8.9/lib/python → pyflyby-1.9.1/bin}/pyflyby/_format.py

@@ -4,9 +4,6 @@
 
 
 
-import six
-
-
 class FormatParams(object):
     max_line_length = None
     _max_line_lenght_default = 79
@@ -24,14 +21,16 @@ class FormatParams(object):
         for arg in args:
             if arg is None:
                 pass
-            elif isinstance(arg, cls):
+            elif isinstance(arg, cls) or hasattr(self, "__dict__"):
                 dicts.append(arg.__dict__)
             else:
-                raise TypeError
+                raise TypeError(
+                    "expected None, or instance of %s cls, got %s" % (cls, arg)
+                )
         if kwargs:
             dicts.append(kwargs)
         for kwargs in dicts:
-            for key, value in six.iteritems(kwargs):
+            for key, value in kwargs.items():
                 if hasattr(self, key):
                     setattr(self, key, value)
                 else:

{pyflyby-1.8.9/lib/python → pyflyby-1.9.1/bin}/pyflyby/_idents.py

@@ -7,10 +7,11 @@
 from   functools                import total_ordering
 from   keyword                  import kwlist
 import re
-import six
 
 from   pyflyby._util            import cached_attribute, cmp
 
+from typing import Optional, Tuple, Dict
+
 
 # Don't consider "print" a keyword, in order to be compatible with user code
 # that uses "from __future__ import print_function".
@@ -46,12 +47,7 @@ def dotted_prefixes(dotted_name, reverse=False):
     return result
 
 
-_name_re               = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*$")
-_dotted_name_re        = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*([.][a-zA-Z_][a-zA-Z0-9_]*)*$")
-_dotted_name_prefix_re = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*([.][a-zA-Z_][a-zA-Z0-9_]*)*[.]?$")
-
-
-def is_identifier(s, dotted=False, prefix=False):
+def is_identifier(s: str, dotted: bool = False, prefix: bool = False):
     """
     Return whether ``s`` is a valid Python identifier name.
 
@@ -111,7 +107,7 @@ def is_identifier(s, dotted=False, prefix=False):
     :rtype:
       ``bool``
     """
-    if not isinstance(s, six.string_types):
+    if not isinstance(s, str):
         raise TypeError("is_identifier(): expected a string; got a %s"
                         % (type(s).__name__,))
     if prefix:
@@ -140,11 +136,15 @@ class BadDottedIdentifierError(ValueError):
 
 # TODO: Use in various places, esp where e.g. dotted_prefixes is used.
 @total_ordering
-class DottedIdentifier(object):
+class DottedIdentifier:
+    name: str
+    parts: Tuple[str, ...]
+    scope_info: Optional[Dict]
+
     def __new__(cls, arg, scope_info=None):
         if isinstance(arg, cls):
             return arg
-        if isinstance(arg, six.string_types):
+        if isinstance(arg, str):
             return cls._from_name(arg, scope_info)
         if isinstance(arg, (tuple, list)):
             return cls._from_name(".".join(arg), scope_info)

{pyflyby-1.8.9/lib/python → pyflyby-1.9.1/bin}/pyflyby/_importclns.py

@@ -17,6 +17,8 @@ from   pyflyby._parse           import PythonBlock
 from   pyflyby._util            import (cached_attribute, cmp, partition,
                                         stable_unique)
 
+from typing import Dict
+
 
 class NoSuchImportError(ValueError):
     pass
@@ -213,8 +215,8 @@ class ImportSet(object):
         """
         :return:
           (mapping from name to __future__ imports,
-           mapping from name to non-'from' imports,
-           mapping from name to 'from' imports)
+          mapping from name to non-'from' imports,
+          mapping from name to 'from' imports)
         """
         ftr_imports = defaultdict(set)
         pkg_imports = defaultdict(set)
@@ -228,9 +230,9 @@ class ImportSet(object):
             else:
                 frm_imports[module_name].add(imp)
         return tuple(
-            dict( (k, frozenset(v))
-                  for k, v in six.iteritems(imports))
-            for imports in [ftr_imports, pkg_imports, frm_imports])
+            dict((k, frozenset(v)) for k, v in imports.items())
+            for imports in [ftr_imports, pkg_imports, frm_imports]
+        )
 
     def get_statements(self, separate_from_imports=True):
         """
@@ -261,8 +263,8 @@ class ImportSet(object):
         if not separate_from_imports:
             def union_dicts(*dicts):
                 result = {}
-                for label, dict in enumerate(dicts):
-                    for k, v in six.iteritems(dict):
+                for label, dct in enumerate(dicts):
+                    for k, v in dct.items():
                         result[(k, label)] = v
                 return result
             groups = [groups[0], union_dicts(*groups[1:])]
@@ -317,8 +319,7 @@ class ImportSet(object):
         d = defaultdict(list)
         for imp in self._importset:
             d[imp.import_as].append(imp)
-        return dict( (k, tuple(sorted(stable_unique(v))))
-                     for k, v in six.iteritems(d) )
+        return dict((k, tuple(sorted(stable_unique(v)))) for k, v in d.items())
 
     @cached_attribute
     def member_names(self):
@@ -347,8 +348,7 @@ class ImportSet(object):
             for prefix in prefixes[1:]:
                 splt = prefix.rsplit(".", 1)
                 d[splt[0]].add(splt[1])
-        return dict( (k, tuple(sorted(v)))
-                     for k, v in six.iteritems(d) )
+        return dict((k, tuple(sorted(v))) for k, v in d.items())
 
     @cached_attribute
     def conflicting_imports(self):
@@ -364,10 +364,7 @@ class ImportSet(object):
         :rtype:
           ``bool``
         """
-        return tuple(
-            k
-            for k, v in six.iteritems(self.by_import_as)
-            if len(v) > 1 and k != "*")
+        return tuple(k for k, v in self.by_import_as.items() if len(v) > 1 and k != "*")
 
     @cached_attribute
     def flags(self):
@@ -522,6 +519,8 @@ class ImportMap(object):
     An ``ImportMap`` is an immutable data structure.
     """
 
+    _data: Dict
+
     def __new__(cls, arg):
         if isinstance(arg, cls):
             return arg
@@ -565,7 +564,7 @@ class ImportMap(object):
         return self._data.items()
 
     def iteritems(self):
-        return six.iteritems(self._data)
+        return self._data.items()
 
     def iterkeys(self):
         return six.iterkeys(self._data)