pyflyby 1.9.4__py3-none-any.whl

pyflyby/_flags.py

@@ -0,0 +1,230 @@
+# pyflyby/_flags.py.
+# Copyright (C) 2011, 2012, 2013, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+
+import __future__
+import ast
+import operator
+from   functools                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 = {}
+_NAME2FLAG = {}
+for name in __future__.all_feature_names:
+    flag = getattr(__future__, name).compiler_flag
+    _FLAG2NAME[flag] = name
+    _NAME2FLAG[name] = flag
+for name in dir(ast):
+    if name.startswith('PyCF'):
+        flag_name = name[len('PyCF_'):].lower()
+        flag = getattr(ast, name)
+        _FLAG2NAME[flag] = flag_name
+        _NAME2FLAG[flag_name] = flag
+_FLAGNAME_ITEMS = sorted(_FLAG2NAME.items())
+_ALL_FLAGS = reduce(operator.or_, _FLAG2NAME.keys())
+
+
+
+class CompilerFlags(int):
+    """
+    Representation of Python "compiler flags", i.e. features from __future__.
+
+      >>> print(CompilerFlags(0x18000).__interactive_display__()) # doctest: +SKIP
+      CompilerFlags(0x18000) # from __future__ import with_statement, print_function
+
+      >>> print(CompilerFlags(0x10000, 0x8000).__interactive_display__()) # doctest: +SKIP
+      CompilerFlags(0x18000) # from __future__ import with_statement, print_function
+
+      >>> print(CompilerFlags('with_statement', 'print_function').__interactive_display__()) # doctest: +SKIP
+      CompilerFlags(0x18000) # from __future__ import with_statement, print_function
+
+      >>> compile("print('x', file=None)", "?", "exec", flags=CompilerFlags("print_function"), dont_inherit=1) #doctest:+ELLIPSIS
+      <code object ...>
+
+    """
+
+    # 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.
+
+        :param args:
+          Any number (zero or more) ``CompilerFlags`` s, ``int`` s, or ``str`` s,
+          which are bitwise-ORed together.
+        :rtype:
+          `CompilerFlags`
+        """
+        if len(args) == 0:
+            return cls._ZERO
+        elif len(args) == 1:
+            arg, = args
+            if isinstance(arg, cls):
+                return arg
+            elif arg is None:
+                return cls._ZERO
+            elif isinstance(arg, int):
+                warnings.warn('creating CompilerFlags from integers is deprecated, '
+                ' flags values change between Python versions. If you are sure use .from_int',
+                DeprecationWarning, stacklevel=2)
+                return cls.from_int(arg)
+            elif isinstance(arg, str):
+                return cls.from_str(arg)
+            elif isinstance(arg, ast.AST):
+                return cls.from_ast(arg)
+            elif isinstance(arg, (tuple, list)):
+                return cls(*arg)
+            else:
+                raise TypeError("CompilerFlags: unknown type %s"
+                                % (type(arg).__name__,))
+        else:
+            flags = []
+            for x in args:
+                if isinstance(x, cls):
+                    flags.append(int(x))
+                elif isinstance(x, int):
+                    warnings.warn(
+                        "creating CompilerFlags from integers is deprecated, "
+                        " flags values change between Python versions. If you are sure use .from_int",
+                        DeprecationWarning,
+                        stacklevel=2,
+                    )
+                    flags.append(x)
+                elif isinstance(x, str):
+                    flags.append(int(cls(x)))
+                else:
+                    raise ValueError
+
+            #assert flags == [0x10000, 0x8000], flags
+
+            return cls.from_int(reduce(operator.or_, flags))
+
+    @classmethod
+    def from_int(cls, arg):
+        if arg == -1:
+            return cls._UNKNOWN  # Instance optimization
+        if arg == 0:
+            return cls._ZERO # Instance optimization
+        self = int.__new__(cls, arg)
+        bad_flags = int(self) & ~_ALL_FLAGS
+        if bad_flags:
+            raise ValueError(
+                "CompilerFlags: unknown flag value(s) %s %s" % (bin(bad_flags), hex(bad_flags)))
+        return self
+
+    @classmethod
+    def from_str(cls, arg:str):
+        try:
+            flag = _NAME2FLAG[arg]
+        except KeyError:
+            raise ValueError(
+                "CompilerFlags: unknown flag %r" % (arg,))
+        return cls.from_int(flag)
+
+    @classmethod
+    def from_ast(cls, nodes):
+        """
+        Parse the compiler flags from AST node(s).
+
+        :type nodes:
+          ``ast.AST`` or sequence thereof
+        :rtype:
+          ``CompilerFlags``
+        """
+        if isinstance(nodes, ast.Module):
+            nodes = nodes.body
+        elif isinstance(nodes, ast.AST):
+            nodes = [nodes]
+        flags = []
+        for node in nodes:
+            if not isinstance(node, ast.ImportFrom):
+                # Got a non-import; stop looking further.
+                break
+            if not node.module == "__future__":
+                # Got a non-__future__-import; stop looking further.
+                break
+            # Get the feature names.
+            names = [n.name for n in node.names]
+            flags.extend(names)
+        return cls(flags)
+
+    @cached_attribute
+    def names(self) -> Tuple[str, ...]:
+        return tuple(
+            n
+            for f, n in _FLAGNAME_ITEMS
+            if f & self)
+
+    def __or__(self, o):
+        if o == 0:
+            return self
+        if not isinstance(o, CompilerFlags):
+            o = CompilerFlags(o)
+        if self == 0:
+            return o
+        return CompilerFlags.from_int(int(self) | int(o))
+
+    def __ror__(self, o):
+        return self | o
+
+    def __and__(self, o):
+        if not isinstance(o, int):
+            o = CompilerFlags(o)
+        return CompilerFlags.from_int(int(self) & int(o))
+
+    def __rand__(self, o):
+        return self & o
+
+    def __xor__(self, o):
+        if not isinstance(o, CompilerFlags):
+            o = CompilerFlags.from_int(o)
+        return CompilerFlags.from_int(int(self) ^ int(o))
+
+    def __rxor__(self, o):
+        return self ^ o
+
+    def __repr__(self):
+        return "CompilerFlags(%s)" % (hex(self),)
+
+    def __str__(self):
+        return hex(self)
+
+    def __interactive_display__(self):
+        s = repr(self)
+        if self != 0:
+            s += " # from __future__ import " + ", ".join(self.names)
+        return s
+
+
+CompilerFlags._ZERO = int.__new__(CompilerFlags, 0)
+CompilerFlags._UNKNOWN = int.__new__(CompilerFlags, -1)
+
+# flags that _may_ exists on future versions.
+_future_flags = {
+    "nested_scopes",
+    "generators",
+    "division",
+    "absolute_import",
+    "with_statement",
+    "print_function",
+    "unicode_literals",
+    "barry_as_FLUFL",
+    "generator_stop",
+    "annotations",
+    "allow_top_level_await",
+    "only_ast",
+    "type_comments",
+}
+for k in _future_flags:
+    setattr(CompilerFlags, k, CompilerFlags._UNKNOWN)
+
+for k, v in _NAME2FLAG.items():
+    setattr(CompilerFlags, k, CompilerFlags.from_int(v))

pyflyby/_format.py

@@ -0,0 +1,182 @@
+# pyflyby/_format.py.
+# Copyright (C) 2011, 2012, 2013, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+
+class FormatParams(object):
+    max_line_length = None
+    _max_line_lenght_default = 79
+    wrap_paren = True
+    indent = 4
+    hanging_indent = 'never'
+    use_black = False
+
+    def __new__(cls, *args, **kwargs):
+        if not kwargs and len(args) == 1 and isinstance(args[0], cls):
+            return args[0]
+        self = object.__new__(cls)
+        # TODO: be more careful here
+        dicts = []
+        for arg in args:
+            if arg is None:
+                pass
+            elif isinstance(arg, cls) or hasattr(self, "__dict__"):
+                dicts.append(arg.__dict__)
+            else:
+                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 kwargs.items():
+                if hasattr(self, key):
+                    setattr(self, key, value)
+                else:
+                    raise ValueError("bad kwarg %r" % (key,))
+        return self
+
+    def __repr__(self):
+        return f'<{self.__class__.__name__} {self.__dict__}>'
+
+
+def fill(tokens, sep=(", ", ""), prefix="", suffix="", newline="\n",
+         max_line_length=80):
+    r"""
+    Given a sequences of strings, fill them into a single string with up to
+    ``max_line_length`` characters each.
+
+      >>> fill(["'hello world'", "'hello two'"],
+      ...            prefix=("print ", "      "), suffix=(" \\", ""),
+      ...            max_line_length=25)
+      "print 'hello world', \\\n      'hello two'\n"
+
+    :param tokens:
+      Sequence of strings to fill.  There must be at least one token.
+    :param sep:
+      Separator string to append to each token.  If a 2-element tuple, then
+      indicates the separator between tokens and the separator after the last
+      token.  Trailing whitespace is removed from each line before appending
+      the suffix, but not from between tokens on the same line.
+    :param prefix:
+      String to prepend at the beginning of each line.  If a 2-element tuple,
+      then indicates the prefix for the first line and prefix for subsequent
+      lines.
+    :param suffix:
+      String to append to the end of each line.  If a 2-element tuple, then
+      indicates the suffix for all lines except the last, and the suffix for
+      the last line.
+    :return:
+      Filled string.
+    """
+    N = max_line_length
+    assert len(tokens) > 0
+    if isinstance(prefix, tuple):
+        first_prefix, cont_prefix = prefix
+    else:
+        first_prefix = cont_prefix = prefix
+    if isinstance(suffix, tuple):
+        nonterm_suffix, term_suffix = suffix
+    else:
+        nonterm_suffix = term_suffix = suffix
+    if isinstance(sep, tuple):
+        nonterm_sep, term_sep = sep
+    else:
+        nonterm_sep = term_sep = sep
+    lines = [first_prefix + tokens[0]]
+    for token, is_last in zip(tokens[1:], [False]*(len(tokens)-2) + [True]):
+        suffix = term_suffix if is_last else nonterm_suffix
+        sep = (term_sep if is_last else nonterm_sep).rstrip()
+        # Does the next token fit?
+        if len(lines[-1] + nonterm_sep + token + sep + suffix) <= N:
+            # Yes; add it.
+            lines[-1] += nonterm_sep + token
+        else:
+            # No; break into new line.
+            lines[-1] += nonterm_sep.rstrip() + nonterm_suffix + newline
+            lines.append(cont_prefix + token)
+    lines[-1] += term_sep.rstrip() + term_suffix + newline
+    return ''.join(lines)
+
+
+def pyfill(prefix, tokens, params=FormatParams()):
+    """
+    Fill a Python statement.
+
+      >>> print(pyfill('print ', ["foo.bar", "baz", "quux", "quuuuux"]), end='')
+      print foo.bar, baz, quux, quuuuux
+      >>> print(pyfill('print ', ["foo.bar", "baz", "quux", "quuuuux"],
+      ...        FormatParams(max_line_length=15, hanging_indent='auto')), end='')
+      print (foo.bar,
+             baz,
+             quux,
+             quuuuux)
+      >>> print(pyfill('print ', ["foo.bar", "baz", "quux", "quuuuux"],
+      ...        FormatParams(max_line_length=14, hanging_indent='auto')), end='')
+      print (
+          foo.bar,
+          baz, quux,
+          quuuuux)
+
+    :param prefix:
+      Prefix for first line.
+    :param tokens:
+      Sequence of string tokens
+    :type params:
+      `FormatParams`
+    :rtype:
+      ``str``
+    """
+    N = params.max_line_length or params._max_line_lenght_default
+    if params.wrap_paren:
+        # Check how we will break up the tokens.
+        len_full = sum(len(tok) for tok in tokens) + 2 * (len(tokens)-1)
+        if len(prefix) + len_full <= N:
+            # The entire thing fits on one line; no parens needed.  We check
+            # this first because breaking into lines adds paren overhead.
+            #
+            # Output looks like:
+            #   from foo import abc, defgh, ijkl, mnopq, rst
+            return prefix + ", ".join(tokens) + "\n"
+        if params.hanging_indent == "never":
+            hanging_indent = False
+        elif params.hanging_indent == "always":
+            hanging_indent = True
+        elif params.hanging_indent == "auto":
+            # Decide automatically whether to do hanging-indent mode.  If any
+            # line would exceed the max_line_length, then do hanging indent;
+            # else don't.
+            #
+            # In order to use non-hanging-indent mode, the first line would
+            # have an overhead of 2 because of "(" and ",".  We check the
+            # longest token since even if the first token fits, we still want
+            # to avoid later tokens running over N.
+            maxtoklen = max(len(token) for token in tokens)
+            hanging_indent = (len(prefix) + maxtoklen + 2 > N)
+        else:
+            raise ValueError("bad params.hanging_indent=%r"
+                             % (params.hanging_indent,))
+        if hanging_indent:
+            # Hanging indent mode.  We need a single opening paren and
+            # continue all imports on separate lines.
+            #
+            # Output looks like:
+            #   from foo import (
+            #       abc, defgh, ijkl,
+            #       mnopq, rst)
+            return (prefix + "(\n"
+                    + fill(tokens, max_line_length=N,
+                           prefix=(" " * params.indent), suffix=("", ")")))
+        else:
+            # Non-hanging-indent mode.
+            #
+            # Output looks like:
+            #   from foo import (abc, defgh,
+            #                    ijkl, mnopq,
+            #                    rst)
+            pprefix = prefix + "("
+            return fill(tokens, max_line_length=N,
+                        prefix=(pprefix, " " * len(pprefix)), suffix=("", ")"))
+    else:
+        raise NotImplementedError

pyflyby/_idents.py

@@ -0,0 +1,233 @@
+# pyflyby/_idents.py.
+# Copyright (C) 2011, 2012, 2013, 2014, 2018 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+
+from   functools                import total_ordering
+from   keyword                  import kwlist
+import re
+
+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".
+_my_kwlist = list(kwlist)
+_my_iskeyword = frozenset(_my_kwlist).__contains__
+
+
+# TODO: use DottedIdentifier.prefixes
+def dotted_prefixes(dotted_name, reverse=False):
+    """
+    Return the prefixes of a dotted name.
+
+      >>> dotted_prefixes("aa.bb.cc")
+      ['aa', 'aa.bb', 'aa.bb.cc']
+
+      >>> dotted_prefixes("aa.bb.cc", reverse=True)
+      ['aa.bb.cc', 'aa.bb', 'aa']
+
+    :type dotted_name:
+      ``str``
+    :param reverse:
+      If False (default), return shortest to longest.  If True, return longest
+      to shortest.
+    :rtype:
+      ``list`` of ``str``
+    """
+    name_parts = dotted_name.split(".")
+    if reverse:
+        idxes = range(len(name_parts), 0, -1)
+    else:
+        idxes = range(1, len(name_parts)+1)
+    result = ['.'.join(name_parts[:i]) or '.' for i in idxes]
+    return result
+
+
+def is_identifier(s: str, dotted: bool = False, prefix: bool = False):
+    """
+    Return whether ``s`` is a valid Python identifier name.
+
+      >>> is_identifier("foo")
+      True
+
+      >>> is_identifier("foo+bar")
+      False
+
+      >>> is_identifier("from")
+      False
+
+    By default, we check whether ``s`` is a single valid identifier, meaning
+    dots are not allowed.  If ``dotted=True``, then we check each dotted
+    component::
+
+      >>> is_identifier("foo.bar")
+      False
+
+      >>> is_identifier("foo.bar", dotted=True)
+      True
+
+      >>> is_identifier("foo..bar", dotted=True)
+      False
+
+      >>> is_identifier("foo.from", dotted=True)
+      False
+
+    By default, the string must comprise a valid identifier.  If
+    ``prefix=True``, then allow strings that are prefixes of valid identifiers.
+    Prefix=False excludes the empty string, strings with a trailing dot, and
+    strings with a trailing keyword component, but prefix=True does not
+    exclude these.
+
+      >>> is_identifier("foo.bar.", dotted=True)
+      False
+
+      >>> is_identifier("foo.bar.", dotted=True, prefix=True)
+      True
+
+      >>> is_identifier("foo.or", dotted=True)
+      False
+
+      >>> is_identifier("foo.or", dotted=True, prefix=True)
+      True
+
+    :type s:
+      ``str``
+    :param dotted:
+      If ``False`` (default), then the input must be a single name such as
+      "foo".  If ``True``, then the input can be a single name or a dotted name
+      such as "foo.bar.baz".
+    :param prefix:
+      If ``False`` (Default), then the input must be a valid identifier.  If
+      ``True``, then the input can be a valid identifier or the prefix of a
+      valid identifier.
+    :rtype:
+      ``bool``
+    """
+    if not isinstance(s, str):
+        raise TypeError("is_identifier(): expected a string; got a %s"
+                        % (type(s).__name__,))
+    if prefix:
+        return is_identifier(s + '_', dotted=dotted, prefix=False)
+    if dotted:
+        return all(is_identifier(w, dotted=False) for w in s.split('.'))
+    return s.isidentifier() and not _my_iskeyword(s)
+
+
+def brace_identifiers(text):
+    """
+    Parse a string and yield all tokens of the form "{some_token}".
+
+      >>> list(brace_identifiers("{salutation}, {your_name}."))
+      ['salutation', 'your_name']
+    """
+    if isinstance(text, bytes):
+        text = text.decode('utf-8', errors='replace')
+    for match in re.finditer("{([a-zA-Z_][a-zA-Z0-9_]*)}", text):
+        yield match.group(1)
+
+
+class BadDottedIdentifierError(ValueError):
+    pass
+
+
+# TODO: Use in various places, esp where e.g. dotted_prefixes is used.
+@total_ordering
+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, str):
+            return cls._from_name(arg, scope_info)
+        if isinstance(arg, (tuple, list)):
+            return cls._from_name(".".join(arg), scope_info)
+        raise TypeError("DottedIdentifier: unexpected %s"
+                        % (type(arg).__name__,))
+
+    @classmethod
+    def _from_name(cls, name, scope_info=None):
+        self = object.__new__(cls)
+        self.name = str(name)
+        # TODO: change magic methods to compare with scopestack included
+        self.scope_info = scope_info
+        if not is_identifier(self.name, dotted=True):
+            if len(self.name) > 20:
+                raise BadDottedIdentifierError("Invalid python symbol name")
+            else:
+                raise BadDottedIdentifierError("Invalid python symbol name %r"
+                                               % (name,))
+        self.parts = tuple(self.name.split('.'))
+        return self
+
+    @cached_attribute
+    def parent(self):
+        if len(self.parts) > 1:
+            return DottedIdentifier('.'.join(self.parts[:-1]))
+        else:
+            return None
+
+    @cached_attribute
+    def prefixes(self):
+        parts = self.parts
+        idxes = range(1, len(parts)+1)
+        result = ['.'.join(parts[:i]) for i in idxes]
+        return tuple(DottedIdentifier(x) for x in result)
+
+    def startswith(self, o):
+        o = type(self)(o)
+        return self.parts[:len(o.parts)] == o.parts
+
+    def __getitem__(self, x):
+        return type(self)(self.parts[x])
+
+    def __len__(self):
+        return len(self.parts)
+
+    def __iter__(self):
+        return (type(self)(x) for x in self.parts)
+
+    def __add__(self, suffix):
+        return type(self)("%s.%s" % (self, suffix))
+
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return "%s(%r)" % (type(self).__name__, self.name)
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __eq__(self, other):
+        if self is other:
+            return True
+        if not isinstance(other, DottedIdentifier):
+            return NotImplemented
+        return self.name == other.name
+
+    def __ne__(self, other):
+        if self is other:
+            return False
+        if not isinstance(other, DottedIdentifier):
+            return NotImplemented
+        return self.name != other.name
+
+    # The rest are defined by total_ordering
+    def __lt__(self, other):
+        if not isinstance(other, DottedIdentifier):
+            return NotImplemented
+        return self.name < other.name
+
+    def __cmp__(self, other):
+        if self is other:
+            return 0
+        if not isinstance(other, DottedIdentifier):
+            return NotImplemented
+        return cmp(self.name, other.name)