pyflyby 1.9.3__tar.gz → 1.9.4__tar.gz

{pyflyby-1.9.3/lib/python/pyflyby.egg-info → pyflyby-1.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyflyby
-Version: 1.9.3
+Version: 1.9.4
 Summary: pyflyby - Python development productivity tools, in particular automatic import management
 Home-page: https://pypi.org/project/pyflyby/
 Author: Karl Chen
@@ -16,8 +16,11 @@ Classifier: Topic :: Software Development :: Interpreters
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
-Requires-Python: >3.6, <4
+Requires-Python: >3.8, <4
 License-File: LICENSE.txt
+Requires-Dist: six
+Requires-Dist: toml
+Requires-Dist: black
 
 #########
  Pyflyby
@@ -29,7 +32,7 @@ License-File: LICENSE.txt
 .. image:: https://travis-ci.org/deshaw/pyflyby.png?branch=master
    :target: https://travis-ci.org/deshaw/pyflyby
 
-Pyflyby is a set of Python programming productivity tools for Python 3.7+.
+Pyflyby is a set of Python programming productivity tools for Python 3.8+.
 
 For command-line interaction:
   * ``py``: command-line multitool

{pyflyby-1.9.3 → pyflyby-1.9.4}/README.rst

@@ -8,7 +8,7 @@
 .. image:: https://travis-ci.org/deshaw/pyflyby.png?branch=master
    :target: https://travis-ci.org/deshaw/pyflyby
 
-Pyflyby is a set of Python programming productivity tools for Python 3.7+.
+Pyflyby is a set of Python programming productivity tools for Python 3.8+.
 
 For command-line interaction:
   * ``py``: command-line multitool

{pyflyby-1.9.3 → pyflyby-1.9.4}/bin/autopython

@@ -1,4 +1,4 @@
-#!/bin/bash -e
+#!/usr/bin/env -S bash -e
 
 # pyflyby/autopython
 

{pyflyby-1.9.3 → pyflyby-1.9.4}/bin/create-imports

@@ -1,4 +1,4 @@
-#!/bin/bash -e
+#!/usr/bin/env -S bash -e
 
 # pyflyby/create-imports
 

{pyflyby-1.9.3 → pyflyby-1.9.4}/bin/pyflyby/__init__.py

@@ -40,6 +40,8 @@ from   pyflyby._dbg             import (breakpoint, debug_exception,
                                         enable_signal_handler_breakpoint,
                                         waitpoint)
 
+from   typing                   import Sequence
+
 
 # Promote the function & classes that we've chosen to expose publicly to be
 # known as pyflyby.Foo instead of pyflyby._module.Foo.
@@ -51,4 +53,4 @@ del x
 
 # Discourage "from pyflyby import *".
 # Use the tidy-imports/autoimporter instead!
-__all__ = []
+__all__:Sequence[str] = []

{pyflyby-1.9.3 → pyflyby-1.9.4}/bin/pyflyby/_autoimp.py

@@ -6,13 +6,9 @@
 
 import ast
 import builtins
+from   collections.abc          import Sequence
 import contextlib
 import copy
-from   six                      import reraise
-import sys
-import types
-
-from collections.abc import Sequence
 
 from   pyflyby._file            import FileText, Filename
 from   pyflyby._flags           import CompilerFlags
@@ -22,7 +18,13 @@ 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, _is_ast_str
+from   pyflyby._parse           import (PythonBlock, _is_ast_str,
+                                        infer_compile_mode)
+
+from   six                      import reraise
+import sys
+import types
+from   typing                   import Any, Set
 
 if sys.version_info >= (3, 12):
     ATTRIBUTE_NAME = "value"
@@ -34,13 +36,13 @@ if sys.version_info > (3, 11):
 else:
     LOAD_SHIFT = 0
 
-if sys.version_info > (3, 11):
-    LOAD_SHIFT = 1
+
+if sys.version_info >= (3, 10):
+    from types import NoneType, EllipsisType
 else:
-    LOAD_SHIFT = 0
+    NoneType = type(None)
+    EllipsisType = type(Ellipsis)
 
-NoneType = type(None)
-EllipsisType = type(Ellipsis)
 
 class _ClassScope(dict):
     pass
@@ -419,7 +421,8 @@ class _MissingImportFinder(object):
 
     def scan_for_import_issues(self, codeblock):
         # See global `scan_for_import_issues`
-        codeblock = PythonBlock(codeblock)
+        if not isinstance(codeblock, PythonBlock):
+            codeblock = PythonBlock(codeblock)
         node = codeblock.ast_node
         self._scan_node(node)
         # Get missing imports now, before handling docstrings.  We don't want
@@ -589,7 +592,10 @@ class _MissingImportFinder(object):
                 logger.warning("Don't know how to handle __all__ with list elements other than str")
                 return
             for e in node.value.elts:
-                self._visit_Load_defered_global(e.s)
+                if sys.version_info > (3,10):
+                    self._visit_Load_defered_global(e.value)
+                else:
+                    self._visit_Load_defered_global(e.s)
 
     def visit_ClassDef(self, node):
         logger.debug("visit_ClassDef(%r)", node)
@@ -634,6 +640,10 @@ class _MissingImportFinder(object):
         else:
             assert node._fields ==  ('name', 'args', 'body', 'decorator_list', 'returns', 'type_comment'), node._fields
         with self._NewScopeCtx(include_class_scopes=True):
+            # we want `__class__` to only be defined in
+            # methods and not class body
+            if self._in_class_def:
+                self.scopestack[-1]["__class__"] = None  # we just need to to be defined
             self.visit(node.decorator_list)
             self.visit(node.args)
             if node.returns:
@@ -1064,7 +1074,8 @@ def scan_for_import_issues(codeblock, find_unused_imports=True, parse_docstrings
 
     """
     logger.debug("scan_for_import_issues()")
-    codeblock = PythonBlock(codeblock)
+    if not isinstance(codeblock, PythonBlock):
+        codeblock = PythonBlock(codeblock)
     namespaces = ScopeStack([{}])
     finder = _MissingImportFinder(namespaces,
                                   find_unused_imports=find_unused_imports,
@@ -1152,10 +1163,13 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
             "_find_loads_without_stores_in_code(): expected a CodeType; got a %s"
             % (type(co).__name__,))
     # Initialize local constants for fast access.
-    from opcode import HAVE_ARGUMENT, EXTENDED_ARG, opmap
+    from opcode import EXTENDED_ARG, opmap
 
     LOAD_ATTR    = opmap['LOAD_ATTR']
+    # LOAD_METHOD is _supposed_ to be removed in 3.12 but still present in opmap
+    # if sys.version_info < (3, 12):
     LOAD_METHOD  = opmap['LOAD_METHOD']
+    # endif
     LOAD_GLOBAL  = opmap['LOAD_GLOBAL']
     LOAD_NAME    = opmap['LOAD_NAME']
     STORE_ATTR   = opmap['STORE_ATTR']
@@ -1255,12 +1269,11 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
     earliest_backjump_label = _find_earliest_backjump_label(bytecode)
     # Loop through bytecode.
     while i < n:
-        c = bytecode[i]
-        op = _op(c)
+        op = bytecode[i]
         i += 1
         if op == CACHE:
             continue
-        if op >= HAVE_ARGUMENT:
+        if take_arg(op):
             oparg = bytecode[i] | extended_arg
             extended_arg = 0
             if op == EXTENDED_ARG:
@@ -1277,9 +1290,40 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
                 stores.add(fullname)
                 continue
             if op in [LOAD_ATTR, LOAD_METHOD]:
-                # {LOAD_GLOBAL|LOAD_NAME} {LOAD_ATTR}* so far;
-                # possibly more LOAD_ATTR/STORE_ATTR will follow
-                pending.append(co.co_names[oparg])
+                if sys.version_info >= (3,12):
+                    # from the docs:
+                    #
+                    # If the low bit of namei is not set, this replaces
+                    # STACK[-1] with getattr(STACK[-1], co_names[namei>>1]).
+                    #
+                    # If the low bit of namei is set, this will attempt to load
+                    # a method named co_names[namei>>1] from the STACK[-1]
+                    # object. STACK[-1] is popped. This bytecode distinguishes
+                    # two cases: if STACK[-1] has a method with the correct
+                    # name, the bytecode pushes the unbound method and
+                    # STACK[-1]. STACK[-1] will be used as the first argument
+                    # (self) by CALL when calling the unbound method. Otherwise,
+                    # NULL and the object returned by the attribute lookup are
+                    # pushed.
+                    #
+                    # Changed in version 3.12: If the low bit of namei is set,
+                    # then a NULL or self is pushed to the stack before the
+                    # attribute or unbound method respectively.
+                    #
+                    # Implication for Pyflyby
+                    #
+                    # In our case I think it means we are always looking at
+                    # oparg>>1 as the name of the names we need to load,
+                    # Though we don't keep track of the stack, and so we may get
+                    # wrong results ?
+                    #
+                    # In any case this seem to match what load_method was doing
+                    # before.
+                    pending.append(co.co_names[oparg>>1])
+                else:
+                    # {LOAD_GLOBAL|LOAD_NAME} {LOAD_ATTR}* so far;
+                    # possibly more LOAD_ATTR/STORE_ATTR will follow
+                    pending.append(co.co_names[oparg])
                 continue
             # {LOAD_GLOBAL|LOAD_NAME} {LOAD_ATTR}* (and no more
             # LOAD_ATTR/STORE_ATTR)
@@ -1366,10 +1410,14 @@ def _find_loads_without_stores_in_code(co, loads_without_stores):
         if isinstance(arg, types.CodeType):
             _find_loads_without_stores_in_code(arg, loads_without_stores)
 
-
-def _op(c):
-    return c
-
+if sys.version_info >= (3,12):
+    from dis import hasarg
+    def take_arg(op):
+        return op in hasarg
+else:
+    def take_arg(op):
+        from opcode import HAVE_ARGUMENT
+        return op >= HAVE_ARGUMENT
 
 def _find_earliest_backjump_label(bytecode):
     """
@@ -1411,19 +1459,20 @@ def _find_earliest_backjump_label(bytecode):
       The earliest target of a backward jump, as an offset into the bytecode.
     """
     # Code based on dis.findlabels().
-    from opcode import HAVE_ARGUMENT, hasjrel, hasjabs
+    from opcode import hasjrel, hasjabs
     if not isinstance(bytecode, bytes):
         raise TypeError
     n = len(bytecode)
     earliest_backjump_label = n
     i = 0
     while i < n:
-        c = bytecode[i]
-        op = _op(c)
+        op = bytecode[i]
         i += 1
-        if op < HAVE_ARGUMENT:
+        if not take_arg(op):
             continue
-        oparg = _op(bytecode[i]) + _op(bytecode[i+1])*256
+        if i+1 >= len(bytecode):
+            break
+        oparg = bytecode[i] + bytecode[i+1]*256
         i += 2
         label = None
         if op in hasjrel:
@@ -1605,7 +1654,7 @@ def get_known_import(fullname, db=None):
     return None
 
 
-_IMPORT_FAILED = set()
+_IMPORT_FAILED:Set[Any] = set()
 """
 Set of imports we've already attempted and failed.
 """

{pyflyby-1.9.3 → pyflyby-1.9.4}/bin/pyflyby/_cmdline.py

@@ -415,8 +415,8 @@ def process_actions(filenames:List[str], actions, modify_function,
             continue
     if errors:
         msg = "\n%s: encountered the following problems:\n" % (sys.argv[0],)
-        for e in errors:
-            lines = e.splitlines()
+        for er in errors:
+            lines = er.splitlines()
             msg += "    " + lines[0] + '\n'.join(
                 ("            %s"%line for line in lines[1:]))
         raise SystemExit(msg)

{pyflyby-1.9.3 → pyflyby-1.9.4}/bin/pyflyby/_comms.py

@@ -9,6 +9,8 @@ from   pyflyby._imports2s       import (SourceToSourceFileImportsTransformation,
 from   pyflyby._importstmt      import Import
 from   pyflyby._log             import logger
 
+from   typing                   import Dict, Any
+
 # These are comm targets that the frontend (lab/notebook) is expected to
 # open. At this point, we handle only missing imports and
 # formatting imports
@@ -23,7 +25,7 @@ PYFLYBY_END_MSG = "# END AUTO-GENERATED BLOCK\n"
 pyflyby_comm_targets= [MISSING_IMPORTS, FORMATTING_IMPORTS, TIDY_IMPORTS]
 
 # A map of the comms opened with a given target name.
-comms = {}
+comms:Dict[str, Any] = {}
 
 # TODO: Document the expected contract for the different
 # custom comm messages

{pyflyby-1.9.3/lib/python → pyflyby-1.9.4/bin}/pyflyby/_file.py

@@ -1,15 +1,14 @@
 # pyflyby/_file.py.
 # Copyright (C) 2011, 2012, 2013, 2014, 2015, 2018 Karl Chen.
 # License: MIT http://opensource.org/licenses/MIT
-
-
+from __future__ import annotations
 
 from   functools                import total_ordering, cached_property
 import io
 import os
 import re
 import sys
-from   typing                   import Optional, Tuple
+from   typing                   import Optional, Tuple, ClassVar
 
 from   pyflyby._util            import cmp, memoize
 
@@ -30,6 +29,7 @@ class Filename(object):
 
     """
     _filename: str
+    STDIN: Filename
 
     def __new__(cls, arg):
         if isinstance(arg, cls):
@@ -236,6 +236,8 @@ class FilePos(object):
     lineno: int
     colno: int
 
+    _ONE_ONE: ClassVar[FilePos]
+
     def __new__(cls, *args):
         if len(args) == 0:
             return cls._ONE_ONE

{pyflyby-1.9.3/lib/python → pyflyby-1.9.4/bin}/pyflyby/_flags.py

@@ -157,7 +157,7 @@ class CompilerFlags(int):
         return cls(flags)
 
     @cached_attribute
-    def names(self) -> Tuple[str]:
+    def names(self) -> Tuple[str, ...]:
         return tuple(
             n
             for f, n in _FLAGNAME_ITEMS

pyflyby-1.9.4/bin/pyflyby/_import_sorting.py

@@ -0,0 +1,165 @@
+"""
+This module contain utility functions to sort imports in a Python Block.
+"""
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass
+from itertools import groupby
+from pyflyby._importstmt import ImportStatement, PythonStatement
+from pyflyby._parse import PythonBlock
+from typing import List, Tuple, Union
+
+
+# @dataclass
+# class ImportSection:
+#     """
+#     This represent an Import
+#     """
+#     sections: List[ImportGroup]
+
+
+@dataclass
+class ImportGroup:
+    """
+    Typically at the top of a file, the first import will be part
+    of an ImportGroup, and subsequent imports
+    will be other import groups which.
+
+    Import sorting will affect only the imports in the same group,
+    as we want import sorting to be indempotent. If import sorting
+    were migrating imports between groups, then imports could be
+    moved to sections were comments would nto be relevant.
+    """
+
+    imports: List[ImportStatement]
+
+    @classmethod
+    def from_statements(cls, statements: List[PythonStatement]) -> ImportGroup:
+        return ImportGroup([ImportStatement(s) for s in statements])
+
+    def sorted(self) -> ImportGroup:
+        """
+        return an ImportGroup with import sorted lexicographically.
+        """
+        return ImportGroup(sorted(self.imports, key=lambda x: x._cmp()))
+
+    def sorted_subgroups(self) -> List[Tuple[bool, List[ImportStatement]]]:
+        """
+        Return a list of subgroup keyed by module and whether they are the sole import
+        from this module.
+
+        From issue #13, we will want to sort import from the same package together when
+        there is more than one import and separat with a blank line
+
+        We also group all imports from a package that appear only once together.
+
+        For this we need both to know if the import is from a single import (the boolean).
+
+        Returns
+        -------
+        bool:
+           wether from a single import
+        List[ImportStatement]
+           The actual import.
+        """
+        c = Counter(imp.module[0] for imp in self.imports)
+        return [
+            (c[k] > 1, list(v)) for k, v in groupby(self.imports, lambda x: x.module[0])
+        ]
+
+
+def split_import_groups(
+    statements: Tuple[PythonStatement],
+) -> List[Union[ImportGroup, PythonStatement]]:
+    """
+    Given a list of statements split into import groups.
+
+    One of the question is how to treat split with comments.
+
+     - Do blank lines after groups with comments start a new block
+     - Does the comment line create a complete new block.
+
+    In particular because we want this to be indempotent,
+    we can't move imports between groups.
+    """
+
+    # these are the import groups we'll
+    groups: List[PythonStatement | ImportGroup] = []
+
+    current_group: List[PythonStatement] = []
+    statemt_iterator = iter(statements)
+    for statement in statemt_iterator:
+        if statement.is_blank and current_group:
+            pass
+            # currently do nothing with whitespace while in import groups.
+        elif statement.is_import:
+            # push on top of current_comment.
+            current_group.append(statement)
+        else:
+            if current_group:
+                groups.append(ImportGroup.from_statements(current_group))
+            current_group = []
+            groups.append(statement)
+
+            # we should break of and populate rest
+            # We can't do anything if we encounter any non-import statement,
+            # as we do no know if it can be a conditional.
+            # technically I guess we coudl find another import block, and reorder these.
+    if current_group:
+        groups.append(ImportGroup.from_statements(current_group))
+
+    # this is an iterator, not an iterable, we exaust it to reify the rest.
+
+    # first group may be empty if the first line is a comment.
+    # We filter and sort relevant statements.
+    groups = [g for g in groups if groups]
+    sorted_groups: List[PythonStatement | ImportGroup] = [
+        g.sorted() if isinstance(g, ImportGroup) else g for g in groups
+    ]
+    return sorted_groups
+
+
+def regroup(groups: List[ImportGroup | PythonStatement]) -> PythonBlock:
+    """
+    given import groups and list of statement, return an Python block with sorted import
+    """
+    res: str = ""
+    in_single = False
+    for group in groups:
+        if isinstance(group, ImportGroup):
+            # the subgroup here will be responsible for  groups reordering.
+            for mult, subgroup in group.sorted_subgroups():
+                if mult:
+                    if in_single:
+                        res += "\n"
+                    if not res.endswith("\n"):
+                        res += "\n"
+                    for x in subgroup:
+                        res += x.pretty_print(import_column=30).rstrip() + "\n"
+                    if not res.endswith("\n\n"):
+                        res += "\n"
+                    in_single = False
+                else:
+                    assert len(subgroup) == 1
+                    in_single = True
+                    for sub in subgroup:
+                        res += str(sub).rstrip() + "\n"
+
+            if not res.endswith("\n\n"):
+                res += "\n"
+        else:
+            if in_single and not res.endswith("\n\n"):
+                res += "\n"
+            in_single = False
+            res += str(PythonBlock(group))
+
+    return PythonBlock.concatenate([PythonBlock(res)])
+
+
+def sort_imports(block: PythonBlock) -> PythonBlock:
+    assert isinstance(block, PythonBlock)
+    # we ignore below that block.statement can be a List[Unknown]
+    gs = split_import_groups(block.statements)  # type: ignore
+    # TODO: math the other fileds like filename....
+    return regroup(gs)

{pyflyby-1.9.3/lib/python → pyflyby-1.9.4/bin}/pyflyby/_importclns.py

@@ -2,6 +2,8 @@
 # Copyright (C) 2011, 2012, 2013, 2014 Karl Chen.
 # License: MIT http://opensource.org/licenses/MIT
 
+from __future__ import annotations
+
 
 
 from   collections              import defaultdict
@@ -16,7 +18,8 @@ from   pyflyby._parse           import PythonBlock
 from   pyflyby._util            import (cached_attribute, cmp, partition,
                                         stable_unique)
 
-from typing import Dict
+from   typing                   import (ClassVar, Dict, FrozenSet, List,
+                                        Sequence, Union)
 
 
 class NoSuchImportError(ValueError):
@@ -46,6 +49,9 @@ class ImportSet(object):
     An ``ImportSet`` is an immutable data structure.
     """
 
+    _EMPTY : ClassVar[ImportSet]
+    _importset : FrozenSet[Import]
+
     def __new__(cls, arg, ignore_nonimports=False, ignore_shadowed=False):
         """
         Return as an `ImportSet`.
@@ -66,7 +72,7 @@ class ImportSet(object):
         """
         if isinstance(arg, cls):
             if ignore_shadowed:
-                return cls._from_imports(arg._importset, ignore_shadowed=True)
+                return cls._from_imports(list(arg._importset), ignore_shadowed=True)
             else:
                 return arg
         return cls._from_args(
@@ -75,7 +81,7 @@ class ImportSet(object):
             ignore_shadowed=ignore_shadowed)
 
     @classmethod
-    def _from_imports(cls, imports, ignore_shadowed=False):
+    def _from_imports(cls, imports:List[Import], ignore_shadowed:bool=False):
         """
         :type imports:
           Sequence of `Import` s
@@ -85,26 +91,30 @@ class ImportSet(object):
           `ImportSet`
         """
         # Canonicalize inputs.
-        imports = [Import(imp) for imp in imports]
+        by_import_as: Dict[Union[str, Import], Import]
+        filtered_imports: Sequence[Import]
+        for imp in imports:
+            assert isinstance(imp, Import)
+        _imports = [Import(imp) for imp in imports]
         if ignore_shadowed:
             # Filter by overshadowed imports.  Later imports take precedence.
             by_import_as = {}
-            for imp in imports:
+            for imp in _imports:
                 if imp.import_as == "*":
                     # Keep all unique star imports.
                     by_import_as[imp] = imp
                 else:
                     by_import_as[imp.import_as] = imp
-            filtered_imports = by_import_as.values()
+            filtered_imports = list(by_import_as.values())
         else:
-            filtered_imports = imports
+            filtered_imports = _imports
         # Construct and return.
         self = object.__new__(cls)
         self._importset = frozenset(filtered_imports)
         return self
 
     @classmethod
-    def _from_args(cls, args, ignore_nonimports=False, ignore_shadowed=False):
+    def _from_args(cls, args, ignore_nonimports:bool=False, ignore_shadowed=False):
         """
         :type args:
           ``tuple`` or ``list`` of `ImportStatement` s, `PythonStatement` s,
@@ -139,7 +149,10 @@ class ImportSet(object):
             elif isinstance(arg, str) and is_identifier(arg, dotted=True):
                 imports.append(Import(arg))
             else: # PythonBlock, PythonStatement, Filename, FileText, str
-                block = PythonBlock(arg)
+                if not isinstance(arg, PythonBlock):
+                    block = PythonBlock(arg)
+                else:
+                    block = arg
                 for statement in block.statements:
                     # Ignore comments/blanks.
                     if statement.is_comment_or_blank:
@@ -170,7 +183,7 @@ class ImportSet(object):
           `ImportSet`
         """
         other = ImportSet(other)
-        return type(self)._from_imports(self._importset | other._importset)
+        return type(self)._from_imports(list(self._importset | other._importset))
 
     def without_imports(self, removals):
         """
@@ -468,17 +481,17 @@ class ImportSet(object):
                 % (type(params.align_imports).__name__,))
         return ''.join(pp(statement, import_column) for statement in statements)
 
-    def __contains__(self, x):
+    def __contains__(self, x) -> bool:
         return x in self._importset
 
-    def __eq__(self, other):
+    def __eq__(self, other) -> bool:
         if self is other:
             return True
         if not isinstance(other, ImportSet):
             return NotImplemented
         return self._importset == other._importset
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         return not (self == other)
 
     # The rest are defined by total_ordering
@@ -497,7 +510,7 @@ class ImportSet(object):
     def __hash__(self):
         return hash(self._importset)
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.imports)
 
     def __iter__(self):
@@ -519,6 +532,7 @@ class ImportMap(object):
     """
 
     _data: Dict
+    _EMPTY : ClassVar[ImportSet]
 
     def __new__(cls, arg):
         if isinstance(arg, cls):