pyflyby 1.9.0__tar.gz → 1.9.2__tar.gz

{pyflyby-1.9.0/lib/python/pyflyby.egg-info → pyflyby-1.9.2}/PKG-INFO

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

{pyflyby-1.9.0 → pyflyby-1.9.2}/bin/pyflyby/_autoimp.py

@@ -22,7 +22,7 @@ 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"
@@ -34,6 +34,11 @@ if sys.version_info > (3, 11):
 else:
     LOAD_SHIFT = 0
 
+if sys.version_info > (3, 11):
+    LOAD_SHIFT = 1
+else:
+    LOAD_SHIFT = 0
+
 NoneType = type(None)
 EllipsisType = type(Ellipsis)
 
@@ -580,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:
@@ -588,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
@@ -600,11 +609,11 @@ class _MissingImportFinder(object):
         if self._in_class_def == 0:
             self.scopestack._class_delayed[node.name] = None
         with self._NewScopeCtx(new_class_scope=True):
-            if not self._in_class_def:
-                self._in_class_def += 1
-                self._visit_Store(node.name)
+            self._in_class_def += 1
+            self._visit_Store(node.name)
             self.visit(node.body)
             self._in_class_def -= 1
+        assert self._in_class_def >= 0
         self._remove_from_missing_imports(node.name)
         self._visit_Store(node.name)
 
@@ -619,7 +628,11 @@ 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.decorator_list)
             self.visit(node.args)

{pyflyby-1.9.0 → pyflyby-1.9.2}/bin/pyflyby/_cmdline.py

@@ -7,11 +7,11 @@
 import optparse
 import os
 import signal
-from   six                      import reraise
-from   six.moves                import input
+from   builtins                 import input
 import sys
 from   textwrap                 import dedent
 import traceback
+from   typing                   import List
 
 
 from   pyflyby._file            import (FileText, Filename, atomic_write_file,
@@ -376,7 +376,7 @@ class Modifier(object):
             f.close()
 
 
-def process_actions(filenames, actions, modify_function,
+def process_actions(filenames:List[str], actions, modify_function,
                     reraise_exceptions=()):
     errors = []
     def on_error_filename_arg(arg):
@@ -408,7 +408,7 @@ def process_actions(filenames, actions, modify_function,
                         # Exception takes more than one argument
                         pass
                 if logger.debug_enabled:
-                    reraise(type_e, e, tb)
+                    raise
                 traceback.print_exception(type(e), e, tb)
             finally:
                 tb = None # avoid refcycles involving tb

{pyflyby-1.9.0/lib/python → pyflyby-1.9.2/bin}/pyflyby/_file.py

@@ -4,13 +4,14 @@
 
 
 
-from   functools                import total_ordering
+from   functools                import total_ordering, cached_property
 import io
 import os
 import re
 import sys
+from   typing                   import Optional, Tuple
 
-from   pyflyby._util            import cached_attribute, cmp, memoize
+from   pyflyby._util            import cmp, memoize
 
 
 class UnsafeFilenameError(ValueError):
@@ -28,6 +29,8 @@ class Filename(object):
       Filename('/etc/passwd')
 
     """
+    _filename: str
+
     def __new__(cls, arg):
         if isinstance(arg, cls):
             return arg
@@ -85,7 +88,7 @@ class Filename(object):
             return NotImplemented
         return cmp(self._filename, o._filename)
 
-    @cached_attribute
+    @cached_property
     def ext(self):
         """
         Returns the extension of this filename, including the dot.
@@ -99,15 +102,15 @@ class Filename(object):
             return None
         return dot + rhs
 
-    @cached_attribute
+    @cached_property
     def base(self):
         return os.path.basename(self._filename)
 
-    @cached_attribute
+    @cached_property
     def dir(self):
         return type(self)(os.path.dirname(self._filename))
 
-    @cached_attribute
+    @cached_property
     def real(self):
         return type(self)(os.path.realpath(self._filename))
 
@@ -230,6 +233,9 @@ class FilePos(object):
     Both lineno and colno are 1-indexed.
     """
 
+    lineno: int
+    colno: int
+
     def __new__(cls, *args):
         if len(args) == 0:
             return cls._ONE_ONE
@@ -265,7 +271,7 @@ class FilePos(object):
             raise TypeError("Expected (int,int); got %r" % (args,))
 
     @classmethod
-    def _from_lc(cls, lineno, colno):
+    def _from_lc(cls, lineno:int, colno:int):
         self = object.__new__(cls)
         self.lineno = lineno
         self.colno  = colno
@@ -338,6 +344,10 @@ class FileText:
     Represents a contiguous sequence of lines from a file.
     """
 
+    filename: Optional[Filename]
+    startpos: FilePos
+    _lines: Optional[Tuple[str, ...]] = None
+
     def __new__(cls, arg, filename=None, startpos=None):
         """
         Return a new ``FileText`` instance.
@@ -371,7 +381,7 @@ class FileText:
             return FileText(arg.__text__(), filename=filename, startpos=startpos)
         elif isinstance(arg, str):
             self = object.__new__(cls)
-            self.joined = arg
+            self._lines = tuple(arg.split('\n'))
         else:
             raise TypeError("%s: unexpected %s"
                             % (cls.__name__, type(arg).__name__))
@@ -383,19 +393,21 @@ class FileText:
         return self
 
     @classmethod
-    def _from_lines(cls, lines, filename, startpos):
+    def _from_lines(cls, lines, filename: Optional[Filename], startpos: FilePos):
         assert type(lines) is tuple
         assert len(lines) > 0
         assert isinstance(lines[0], str)
         assert not lines[-1].endswith("\n")
+        assert isinstance(startpos, FilePos), repr(startpos)
+        assert isinstance(filename, (Filename, type(None))), repr(filename)
         self = object.__new__(cls)
-        self.lines    = lines
+        self._lines    = tuple(lines)
         self.filename = filename
         self.startpos = startpos
         return self
 
-    @cached_attribute
-    def lines(self):
+    @cached_property
+    def lines(self) -> Tuple[str, ...]:
         r"""
         Lines that have been split by newline.
 
@@ -408,16 +420,19 @@ class FileText:
         :rtype:
           ``tuple`` of ``str``
         """
+        if self._lines is not None:
+            return self._lines
         # Used if only initialized with 'joined'.
         # We use str.split() instead of str.splitlines() because the latter
         # doesn't distinguish between strings that end in newline or not
         # (or requires extra work to process if we use splitlines(True)).
         return tuple(self.joined.split('\n'))
 
-    @cached_attribute
-    def joined(self): # used if only initialized with 'lines'
+    @cached_property
+    def joined(self) -> str:
         return '\n'.join(self.lines)
 
+
     @classmethod
     def from_filename(cls, filename):
         return cls.from_lines(Filename(filename))
@@ -435,13 +450,12 @@ class FileText:
             return self
         else:
             result = object.__new__(type(self))
-            result.lines    = self.lines
-            result.joined   = self.joined
+            result._lines   = self._lines
             result.filename = filename
             result.startpos = startpos
             return result
 
-    @cached_attribute
+    @cached_property
     def endpos(self):
         """
         The position after the last character in the text.

{pyflyby-1.9.0/lib/python → pyflyby-1.9.2/bin}/pyflyby/_importclns.py

@@ -215,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)

{pyflyby-1.9.0 → pyflyby-1.9.2}/bin/pyflyby/_imports2s.py

@@ -3,7 +3,6 @@
 # License: MIT http://opensource.org/licenses/MIT
 from collections import defaultdict
 
-import isort
 from   pyflyby._autoimp         import scan_for_import_issues
 from   pyflyby._file            import FileText, Filename
 from   pyflyby._flags           import CompilerFlags
@@ -14,10 +13,12 @@ from   pyflyby._log             import logger
 from   pyflyby._parse           import PythonBlock
 from   pyflyby._util            import ImportPathCtx, Inf, NullCtx, memoize
 import re
-from   six                      import exec_
 
 
 class SourceToSourceTransformationBase(object):
+
+    input: PythonBlock
+
     def __new__(cls, arg):
         if isinstance(arg, cls):
             return arg
@@ -52,11 +53,15 @@ class SourceToSourceTransformationBase(object):
 
 
 class SourceToSourceTransformation(SourceToSourceTransformationBase):
+
+    _output: PythonBlock
+
     def preprocess(self):
-        self.output = self.input
+        assert isinstance(self.input, PythonBlock), self.input
+        self._output = self.input
 
     def pretty_print(self, params=None):
-        return self.output.text
+        return self._output.text
 
 
 class SourceToSourceImportBlockTransformation(SourceToSourceTransformationBase):
@@ -195,12 +200,10 @@ class SourceToSourceFileImportsTransformation(SourceToSourceTransformationBase):
                     # insert in the middle.
                     self.blocks[:1] = (
                         [SourceToSourceTransformation(
-                            PythonBlock.concatenate(statements[:idx],
-                                                    assume_contiguous=True))] +
+                            PythonBlock.concatenate(statements[:idx]))] +
                         blocks +
                         [SourceToSourceTransformation(
-                            PythonBlock.concatenate(statements[idx:],
-                                                    assume_contiguous=True))])
+                            PythonBlock.concatenate(statements[idx:]))])
                 break
         else:
             # First block is entirely comments, so just insert after it.
@@ -214,7 +217,7 @@ class SourceToSourceFileImportsTransformation(SourceToSourceTransformationBase):
         """
         block = SourceToSourceImportBlockTransformation("")
         sepblock = SourceToSourceTransformation("")
-        sepblock.output = PythonBlock("\n")
+        sepblock._output = PythonBlock("\n")
         self.insert_new_blocks_after_comments([block, sepblock])
         self.import_blocks.insert(0, block)
         return block
@@ -433,7 +436,7 @@ def remove_broken_imports(codeblock, params=None):
         for imp in list(block.importset.imports):
             ns = {}
             try:
-                exec_(imp.pretty_print(), ns)
+                exec(imp.pretty_print(), ns)
             except Exception as e:
                 logger.info("%s: Could not import %r; removing it: %s: %s",
                             filename, imp.fullname, type(e).__name__, e)
@@ -540,6 +543,7 @@ def sort_imports(codeblock):
     :param codeblock:
     :return: codeblock
     """
+    import isort
     sorted_imports = isort.code(
         str(codeblock),
         # To sort all the import in lexicographic order
@@ -644,7 +648,7 @@ def transform_imports(codeblock, transformations, params=None):
             output_imports = [ transform_import(imp) for imp in input_imports ]
             block.importset = ImportSet(output_imports, ignore_shadowed=True)
         else:
-            block.output = transform_block(block.input)
+            block._output = transform_block(block.input)
     return transformer.output(params=params)
 
 

{pyflyby-1.9.0 → pyflyby-1.9.2}/bin/pyflyby/_importstmt.py

@@ -15,17 +15,16 @@ from   pyflyby._parse           import PythonStatement
 from   pyflyby._util            import (Inf, cached_attribute, cmp,
                                         longest_common_prefix)
 
-from   black                    import format_str, FileMode as Mode
-from   black.files              import find_pyproject_toml, parse_pyproject_toml
-from   black.mode               import TargetVersion
 
+from   typing                   import Dict, Tuple, Optional
 
-def read_black_config():
-    """Read the black configuration from ``pyproject.toml``
 
 
-    """
-    pyproject_path = find_pyproject_toml('.')
+def read_black_config() -> Dict:
+    """Read the black configuration from ``pyproject.toml``"""
+    from black.files import find_pyproject_toml, parse_pyproject_toml
+
+    pyproject_path = find_pyproject_toml((".",))
 
     raw_config = parse_pyproject_toml(pyproject_path) if pyproject_path else {}
 
@@ -348,24 +347,31 @@ class Import(object):
             return NotImplemented
         return self._data < other._data
 
-def _validate_alias(arg):
+def _validate_alias(arg) -> Tuple[str, Optional[str]]:
     """
     Ensure each alias is a tuple (str, None|str), and return it.
 
     """
     assert isinstance(arg, tuple)
-    a0,a1 = arg
+    # Pyright does not seem to be able to infer the length from a
+    # the unpacking.
+    assert len(arg) == 2
+    a0, a1 = arg
     assert isinstance(a0, str)
     assert isinstance(a1, (str, type(None)))
     return arg
 
 @total_ordering
-class ImportStatement(object):
+class ImportStatement:
     """
     Token-level representation of an import statement containing multiple
     imports from a single module.  Corresponds to an ``ast.ImportFrom`` or
     ``ast.Import``.
     """
+
+    aliases : Tuple[Tuple[str, Optional[str]],...]
+    fromname : Optional[str]
+
     def __new__(cls, arg):
         if isinstance(arg, cls):
             return arg
@@ -381,10 +387,10 @@ class ImportStatement(object):
         raise TypeError
 
     @classmethod
-    def from_parts(cls, fromname, aliases):
-        assert isinstance(aliases, list)
+    def from_parts(cls, fromname:Optional[str], aliases:Tuple[Tuple[str, Optional[str]],...]):
+        assert isinstance(aliases, tuple)
         assert len(aliases) > 0
-        
+
         self = object.__new__(cls)
         self.fromname = fromname
         self.aliases = tuple(_validate_alias(a) for a in aliases)
@@ -440,7 +446,7 @@ class ImportStatement(object):
             raise NonImportStatementError(
                     'Expected ImportStatement, got {node}'.format(node=node)
                     )
-        aliases = [ (alias.name, alias.asname) for alias in node.names ]
+        aliases = tuple( (alias.name, alias.asname) for alias in node.names )
         return cls.from_parts(fromname, aliases)
 
     @classmethod
@@ -463,7 +469,7 @@ class ImportStatement(object):
             raise ValueError(
                 "Inconsistent module names %r" % (sorted(module_names),))
         fromname = list(module_names)[0]
-        aliases = [ imp.split[1:] for imp in imports ]
+        aliases = tuple(imp.split[1:] for imp in imports)
         return cls.from_parts(fromname, aliases)
 
     @cached_attribute
@@ -529,12 +535,15 @@ class ImportStatement(object):
         return res
 
     @staticmethod
-    def run_black(src_contents: str, params) -> str:
+    def run_black(src_contents: str, params:FormatParams) -> str:
         """Run the black formatter for the Python source code given as a string
 
         This is adapted from https://github.com/akaihola/darker
 
         """
+        from black import format_str, FileMode
+        from black.mode import TargetVersion
+
         black_config = read_black_config()
         mode = dict()
         if "line_length" in black_config:
@@ -568,14 +577,12 @@ class ImportStatement(object):
             # ``--skip-string-normalization``, but the parameter for
             # ``black.Mode`` needs to be the opposite boolean of
             # ``skip-string-normalization``, hence the inverse boolean
-            mode["string_normalization"] = not black_config[
-                "skip_string_normalization"
-            ]
+            mode["string_normalization"] = not black_config["skip_string_normalization"]
 
         # The custom handling of empty and all-whitespace files below will be unnecessary if
         # https://github.com/psf/black/pull/2484 lands in Black.
         contents_for_black = src_contents
-        return format_str(contents_for_black, mode=Mode(**mode))
+        return format_str(contents_for_black, mode=FileMode(**mode))
 
     @property
     def _data(self):

{pyflyby-1.9.0/lib/python → pyflyby-1.9.2/bin}/pyflyby/_modules.py

@@ -125,6 +125,8 @@ class ModuleHandle(object):
     A handle to a module.
     """
 
+    name: DottedIdentifier
+
     def __new__(cls, arg):
         if isinstance(arg, cls):
             return arg
@@ -206,14 +208,8 @@ class ModuleHandle(object):
         if self.parent and not self.parent.exists:
             return False
 
-        # pkgutil.find_loader returns None for unimported Python 3
-        # namespace packages, so prefer importlib
-        try:
-            import importlib.util
-            find = importlib.util.find_spec
-        except ImportError:
-            import pkgutil
-            find = pkgutil.find_loader
+        import importlib.util
+        find = importlib.util.find_spec
 
         try:
             pkg = find(name)
@@ -241,6 +237,7 @@ class ModuleHandle(object):
         # module, which may be undesirable.
         import pkgutil
         try:
+             #TODO: deprecated and will be removed in 3.14
             loader = pkgutil.get_loader(str(self.name))
         except ImportError:
             return None
@@ -303,7 +300,7 @@ class ModuleHandle(object):
         Enumerate the importable submodules of this module.
 
           >>> ModuleHandle("email").submodules      # doctest:+ELLIPSIS
-          (..., 'email.encoders', ..., 'email.mime', ...)
+          (..., ModuleHandle('email.encoders'), ..., ModuleHandle('email.mime'), ...)
 
         :rtype:
           ``tuple`` of `ModuleHandle` s
@@ -366,6 +363,7 @@ class ModuleHandle(object):
 
         # If __all__ is defined, try to use it
         all_is_good = False  # pun intended
+        all_members = []
         if "__all__" in members:
             # Iterate through the nodes and reconstruct the
             # value of __all__
@@ -418,7 +416,7 @@ class ModuleHandle(object):
         members = [n for n in members if not n.startswith("_")]
 
         # Filter out artificially added "deep" members.
-        members = [(n, None) for n in members if "." not in n]
+        members = tuple([(n, None) for n in members if "." not in n])
         if not members:
             return None
         return ImportSet(
@@ -482,7 +480,11 @@ class ModuleHandle(object):
             result = module.module
         except Exception as e:
             raise ImportError(e)
-        for part, prefix in zip(identifier, prefixes(identifier))[1:]:
+        # TODO: as far as I can tell the code here is never reached, or haven't
+        # been in quite some time as the line below was invalid on Python 3 since 2011
+        # zip(...)[...] fails as zip is not indexable.
+        # the only place that seem to be using this method is XrefScanner.
+        for part, prefix in list(zip(identifier, prefixes(identifier)))[1:]:
             try:
                 result = getattr(result, str(part))
             except Exception: