pyflyby 1.10.4__cp311-cp311-macosx_11_0_arm64.whl

pyflyby/libexec/pyflyby/diff-colorize

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+
+
+import fileinput
+import os
+import re
+import sys
+
+# TERM could be e.g. xterm-256color or screen-256color.
+has_256_color = ('-256col' in os.environ.get('TERM', ''))
+
+index_color      = int(os.environ.get('DIFF_INDEX_COLOR',
+                                      has_256_color and 32 or 36))
+old_mode_color   = int(os.environ.get('DIFF_OLD_MODE_COLOR',
+                                      has_256_color and 88 or 31))
+new_mode_color   = int(os.environ.get('DIFF_NEW_MODE_COLOR',
+                                      has_256_color and 28 or 32))
+removed_color    = int(os.environ.get('DIFF_REMOVED_COLOR',
+                                      has_256_color and 160 or 31))
+added_color      = int(os.environ.get('DIFF_ADDED_COLOR',
+                                      has_256_color and 2 or 32))
+hunk_start_color = int(os.environ.get('DIFF_HUNK_START_COLOR',
+                                      has_256_color and 32 or 36))
+trailing_whitespace_color = int(has_256_color and 236 or 8)
+
+
+RESET_FORMAT = '\033[0m'
+COLOR_FORMAT_256 = '\033[38;5;%um'
+COLOR_FORMAT_16 = '\033[38;%um'
+BG_COLOR_FORMAT_256 = '\033[48;5;%um'
+BG_COLOR_FORMAT_16 = '\033[48;%um'
+COLOR_FORMAT = has_256_color and COLOR_FORMAT_256 or COLOR_FORMAT_16
+BG_COLOR_FORMAT = has_256_color and BG_COLOR_FORMAT_256 or BG_COLOR_FORMAT_16
+BEGIN_REVERSE_FORMAT = '\033[7m'
+END_REVERSE_FORMAT = '\033[27m'
+
+USAGE = """
+Usage: diff ... | diff-colorize
+   or:            diff-colorize < foo.diff
+
+Reads unified or git-style diff data from standard input, colorizes it, and
+writes the result to standard output.
+""".strip()
+
+# You can customize the color numbers used by setting these variables in your environment:
+# * DIFF_INDEX_COLOR (lines starting with "Index: " or "diff --git ")
+# * DIFF_OLD_MODE_COLOR (lines starting with "old mode"; these only appear in git-style diffs)
+# * DIFF_NEW_MODE_COLOR (lines starting with "new mode"; these only appear in git-style diffs)
+# * DIFF_REMOVED_COLOR (lines starting with "-")
+# * DIFF_ADDED_COLOR (lines starting with "+")
+# * DIFF_HUNK_START_COLOR (lines starting with "@@")
+
+# Everything in the unified diff format is identified by a prefix. The prefixes are:
+# 'Index: ':    File marker (unified diff)
+# 'diff --git': File marker (git-style diff)
+# 'old mode':   File permissions mode before change
+# 'new mode':   File permissions mode after change
+# '---':        Defining '-' (giving the name and modification date of the file before change)
+# '+++':        Defining '+' (giving the name and modification date of the file after change)
+# '-':          Line before change (i.e., removed)
+# '+':          Line after change (i.e., added)
+# ' ':          Line that hasn't changed
+# '@@':         Hunk start (@@ -start,length +start, length @@)
+#
+# We need to look for these prefixes in order, in order to handle '---'/'+++' before '-'/'+'. Hence the OrderedDict.
+class OrderedDict(dict):
+    def __init__(self, input=None):
+        if input is None:
+            self.keys = []
+            super(OrderedDict, self).__init__()
+        elif isinstance(input, dict):
+            self.keys = list(input)
+            super(OrderedDict, self).__init__(input)
+        else:
+            self.keys = [k for k, v in input]
+            super(OrderedDict, self).__init__(input)
+    def __iter__(self):
+        return iter(self.keys)
+    def __setitem__(self, k, v):
+        if k not in self:
+            self.keys.append(k)
+        super(OrderedDict, self).__setitem__(k, v)
+    def __delitem__(self, k):
+        super(OrderedDict, self).__delitem__(k)
+        self.keys.remove(k)
+
+# Each value includes not only the terminal-config characters, but also the key, somewhere within it (possibly between two terminal-config strings).
+# Theoretically, you could replace the key with some other string or leave it out entirely, if you wanted to, but I wouldn't recommend it.
+prefixes = OrderedDict()
+prefixes['---'] = (
+    COLOR_FORMAT % (removed_color,)
+    + BEGIN_REVERSE_FORMAT
+    + '---'
+    + END_REVERSE_FORMAT
+)
+prefixes['+++'] = (
+    COLOR_FORMAT % (added_color,)
+    + BEGIN_REVERSE_FORMAT
+    + '+++'
+    + END_REVERSE_FORMAT
+)
+prefixes['-'] = (
+    COLOR_FORMAT % (removed_color,)
+    + BEGIN_REVERSE_FORMAT
+    + '-'
+    + END_REVERSE_FORMAT
+)
+prefixes['+'] = (
+    COLOR_FORMAT % (added_color,)
+    + BEGIN_REVERSE_FORMAT
+    + '+'
+    + END_REVERSE_FORMAT
+)
+prefixes['old mode'] = ( # Git-style diffs only
+    COLOR_FORMAT % (old_mode_color,)
+    + BEGIN_REVERSE_FORMAT
+    + 'old mode'
+    + END_REVERSE_FORMAT
+)
+prefixes['new mode'] = ( # Git-style diffs only
+    COLOR_FORMAT % (new_mode_color,)
+    + BEGIN_REVERSE_FORMAT
+    + 'new mode'
+    + END_REVERSE_FORMAT
+)
+prefixes['Index: '] = COLOR_FORMAT % (index_color,) + 'Index: '
+prefixes['diff --git '] = COLOR_FORMAT % (index_color,) + 'diff --git '
+prefixes['@@'] = (
+    COLOR_FORMAT % (hunk_start_color,)
+    # + BEGIN_REVERSE_FORMAT
+    + '@@'
+)
+trailing_whitespace_repl = r'\1%s\2' % (BG_COLOR_FORMAT % (trailing_whitespace_color,),)
+
+if sys.stdin.isatty():
+    # Standard input is a TTY, meaning that the user ran 'diff-colorize' at the shell prompt, without redirecting anything into it. Print usage info and exit.
+    sys.exit(USAGE)
+
+for line in fileinput.input():
+    for prefix_to_test in prefixes:
+        if line.startswith(prefix_to_test):
+            sys.stdout.write(prefixes[prefix_to_test])
+            line = line[len(prefix_to_test):]
+    line = re.sub('([^ \t])([ \t]+)$', trailing_whitespace_repl, line)
+
+    sys.stdout.write(line)
+
+    sys.stdout.write(RESET_FORMAT)

pyflyby/share/emacs/site-lisp/pyflyby.el

@@ -0,0 +1,112 @@
+
+(require 'find-func) ;; for find-library-name
+
+(defvar pyflyby-bin-path
+  ;; Try to find the bin path based on where pyflyby.el lives.
+  (let* ((pyflyby-el-name
+          (or load-file-name
+              (ignore-errors (find-library-name "pyflyby"))
+              "pyflyby.el"))
+         (module-path (file-truename pyflyby-el-name))
+         (binpath (file-truename
+                   (concat (file-name-directory module-path) "../../bin"))))
+    (and (file-directory-p binpath) binpath))
+  "Path containing pyflyby executables.")
+
+
+(defun pyflyby--pipe-to-command (start end program &rest args)
+  "Send text from START to END to process running PROGRAM ARGS.
+
+Returns (exit-value stdout stderr)."
+  ;; Yuck: call-process-region can only redirect stderr to a file, not to a
+  ;; buffer/string.
+  (let* ((stdout-buffer (generate-new-buffer " *pyflyby stdout*"))
+         (stderr-buffer (generate-new-buffer " *pyflyby stderr*"))
+         (stderr-file (make-temp-file
+                       (expand-file-name
+                        "pyflyby-log."
+                        (or small-temporary-file-directory
+                            temporary-file-directory))))
+         (exec-path (if pyflyby-bin-path
+                        (cons pyflyby-bin-path exec-path) exec-path))
+         (exit-value (apply 'call-process-region
+                            start end program nil
+                            (list stdout-buffer stderr-file)
+                            nil args))
+         (stdout-text (with-current-buffer stdout-buffer (buffer-string)))
+         (stderr-text (with-current-buffer stderr-buffer
+                        (format-insert-file stderr-file nil)
+                        (buffer-string))))
+    (delete-file stderr-file)
+    (kill-buffer stdout-buffer)
+    (kill-buffer stderr-buffer)
+    (list exit-value stdout-text stderr-text)))
+
+
+(defun pyflyby--replace-text (text)
+  "Replace current buffer with TEXT.
+
+Tries to keep point in the same place."
+  (let* ((p (point))
+         (ptext (buffer-substring-no-properties
+                 p (min (point-max) (+ p 1000))))
+         (size (buffer-size)))
+    ;; Replace the buffer.
+    (erase-buffer)
+    (insert text)
+    ;; Go to previously saved point.  We don't use save-excursion
+    ;; since that doesn't work when the whole buffer is replaced,
+    ;; destroying markers.  First see if the position matches when
+    ;; counting from end of the buffer.
+    (setq p (max 0 (+ p (buffer-size) (- size))))
+    (goto-char p)
+    (unless (search-forward ptext (+ p 1) t)
+      ;; Next, try searching for the location based on text near old
+      ;; point.
+      (goto-char (- p 500))
+      (if (search-forward ptext (+ p 1000) t)
+          (goto-char (match-beginning 0))
+        (goto-char p)))
+    ;; Only recenter when the buffer is visible in a live window.
+    (let ((win (get-buffer-window (current-buffer) t)))
+      (when (and win (window-live-p win))
+        (with-selected-window win
+          (recenter))))))
+
+
+(defun pyflyby-transform-region-with-command (command &rest args)
+  (unless (eq major-mode 'python-mode)
+    (error "Pyflyby should only be used on python buffers"))
+  (let* ((result
+          (apply 'pyflyby--pipe-to-command (point-min) (point-max) command args))
+         (exit-value (nth 0 result))
+         (newtext (nth 1 result))
+         (logtext (nth 2 result))
+         (logtext (replace-regexp-in-string "/dev/stdin: ?" "" logtext nil t))
+         (nlogtext (if (= 0 (length logtext)) "" (concat "\n" logtext))))
+    (if (= exit-value 0)
+        ;; Process exited successfully.
+        (if (string= newtext
+                     (buffer-substring-no-properties (point-min) (point-max)))
+            ;; No change.
+            (message "No changes by `%s'.%s" command nlogtext)
+          ;; There were changes.
+          (pyflyby--replace-text newtext)
+          (message logtext))
+      ;; Process failed.
+      (error "%s failed with exit code %d.%s" command exit-value logtext))))
+
+
+(defun pyflyby-tidy-imports ()
+  (interactive "*")
+  (pyflyby-transform-region-with-command "tidy-imports"))
+
+(defun pyflyby-reformat-imports ()
+  (interactive "*")
+  (pyflyby-transform-region-with-command "reformat-imports"))
+
+
+(defalias 'tidy-imports 'pyflyby-tidy-imports)
+(defalias 'reformat-imports 'pyflyby-reformat-imports)
+
+(provide 'pyflyby)

pyflyby-1.10.4.data/scripts/collect-exports

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""
+collect-exports module1 module2...
+
+Collect all exports in the specified modules and generate "from foo import
+..." lines for public members defined in those modules.
+
+Print the result to stdout.
+
+"""
+
+# pyflyby/collect-exports
+# Copyright (C) 2011, 2012, 2013, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+
+import sys
+
+from   pyflyby._cmdline         import hfmt, parse_args
+from   pyflyby._importdb        import ImportDB
+from   pyflyby._log             import logger
+from   pyflyby._modules         import ModuleHandle
+
+
+def main():
+    def addopts(parser):
+        parser.add_option("--ignore-known", default=False, action='store_true',
+                          help=hfmt('''
+                                Don't list imports already in the
+                                known-imports database.'''))
+        parser.add_option("--no-ignore-known", dest="ignore_known",
+                          action='store_false',
+                          help=hfmt('''
+                                (Default) List all imports, including those
+                                already in the known-imports database.'''))
+        parser.add_option("--expand-known", default=False, action='store_true',
+                          help=hfmt('''
+                                Scan all modules mentioned in known-imports
+                                database.'''))
+        parser.add_option("--no-expand-known", dest="expand_known",
+                          action='store_false',
+                          help=hfmt('''
+                                (Default) Scan only modules listed explicitly
+                                on the command line.'''))
+    options, args = parse_args(addopts, import_format_params=True)
+    if options.expand_known:
+        db = ImportDB.get_default(".")
+        known = db.known_imports.imports
+        args += sorted(set(
+                [_f for _f in [i.split.module_name for i in known] if _f]))
+    bad_module_names = []
+    for module_name in args:
+        module = ModuleHandle(module_name)
+        try:
+            imports = module.exports
+        except Exception as e:
+            logger.warning("couldn't get exports for %s; ignoring: %s: %s",
+                           module, type(e).__name__, e)
+            bad_module_names.append(module_name)
+            continue
+        if not imports:
+            continue
+        if options.ignore_known:
+            db = ImportDB.get_default(module.__file__)
+            imports = imports.without_imports(db)
+        sys.stdout.write(imports.pretty_print(
+                allow_conflicts=True, params=options.params))
+    if bad_module_names:
+        print("collect-exports: there were problems with: %s" % (
+            ' '.join(bad_module_names)), file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

pyflyby-1.10.4.data/scripts/collect-imports

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+"""
+collect-imports *.py
+collect-imports < foo.py
+
+Collect all imports from named files or stdin, and combine them into a single
+block of import statements.  Print the result to stdout.
+
+"""
+# pyflyby/collect-imports
+# Copyright (C) 2011, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+import re
+import sys
+
+from   pyflyby._cmdline         import filename_args, hfmt, parse_args
+from   pyflyby._importclns      import ImportSet
+from   pyflyby._importdb        import ImportDB
+
+
+def main():
+    def addopts(parser):
+        parser.add_option("--ignore-known", default=False, action='store_true',
+                          help=hfmt('''
+                                Don't list imports already in the
+                                known-imports database.'''))
+        parser.add_option("--no-ignore-known", dest="ignore_known",
+                          action='store_false',
+                          help=hfmt('''
+                                (Default) List all imports, including those
+                                already in the known-imports database.'''))
+        parser.add_option("--include",
+                          default=[], action="append",
+                          help=hfmt('''
+                                Include only imports under the given package.'''))
+    options, args = parse_args(addopts, import_format_params=True)
+    filenames = filename_args(args)
+    importset = ImportSet(filenames, ignore_nonimports=True)
+    if options.include:
+        regexps = [
+            re.escape(prefix) if prefix.endswith(".") else
+            re.escape(prefix) + "([.]|$)"
+            for prefix in options.include
+        ]
+        regexp = re.compile("|".join(regexps))
+        match = lambda imp: regexp.match(imp.fullname)
+        importset = ImportSet([imp for imp in importset if match(imp)])
+    if options.ignore_known:
+        db = ImportDB.get_default(".")
+        importset = importset.without_imports(db.known_imports)
+    sys.stdout.write(importset.pretty_print(
+            allow_conflicts=True, params=options.params))
+
+
+if __name__ == '__main__':
+    main()

pyflyby-1.10.4.data/scripts/find-import

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+"""
+Usage: find-import names...
+
+Prints how to import given name(s).
+"""
+# pyflyby/find-import
+# Copyright (C) 2011, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+from   pyflyby._cmdline         import parse_args, syntax
+from   pyflyby._importdb        import ImportDB
+from   pyflyby._log             import logger
+
+
+def main():
+    options, args = parse_args(import_format_params=True)
+    if not args:
+        syntax()
+    db = ImportDB.get_default(".")
+    known = db.known_imports.by_import_as
+    errors = 0
+    for arg in args:
+        try:
+            imports = known[arg]
+        except KeyError:
+            errors += 1
+            logger.error("Can't find import for %r", arg)
+        else:
+            for imp in imports:
+                print(imp.pretty_print(params=options.params), end=' ')
+    if errors:
+        raise SystemExit(1)
+
+
+if __name__ == '__main__':
+    main()

pyflyby-1.10.4.data/scripts/prune-broken-imports

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+prune-broken-imports *.py
+prune-broken-imports < foo.py
+
+Removes broken imports.
+
+Note: This actually executes imports.
+
+If filenames are given on the command line, rewrites them.  Otherwise, if
+stdin is not a tty, read from stdin and write to stdout.
+
+Only top-level import statements are touched.
+
+"""
+# pyflyby/prune-broken-imports
+# Copyright (C) 2012, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+from   pyflyby._cmdline         import parse_args, process_actions
+from   pyflyby._imports2s       import remove_broken_imports
+
+
+def main():
+    options, args = parse_args(
+        import_format_params=True, modify_action_params=True)
+    def modify(x):
+        return remove_broken_imports(x, params=options.params)
+    process_actions(args, options.actions, modify)
+
+
+if __name__ == '__main__':
+    main()

pyflyby-1.10.4.data/scripts/pyflyby-diff

@@ -0,0 +1,34 @@
+#!/usr/bin/env -S bash -e
+
+# License for THIS FILE ONLY: CC0 Public Domain Dedication
+# http://creativecommons.org/publicdomain/zero/1.0/
+
+# Get the directory containing to the symlink target of the script.
+if script=$(readlink -e "$0" 2>/dev/null) && [[ "$script" -ef "$0" ]]; then
+    scriptdir=$(dirname "$script")
+elif script=$(realpath "$0" 2>/dev/null) && [[ "$script" -ef "$0" ]]; then
+    scriptdir=$(dirname "$script")
+elif script=$(greadlink -e "$0" 2>/dev/null) && [[ "$script" -ef "$0" ]]; then
+    scriptdir=$(dirname "$script")
+else
+    scriptdir=$(
+        d=$(dirname "$0")
+        b=$(basename "$0")
+        cd "$d"
+        if l=$(readlink "$b"); then
+            ld=$(dirname "$l")
+            cd "$ld"
+        fi
+        pwd
+    )
+fi
+
+libexecdir="$scriptdir/../libexec/pyflyby"
+
+PATH="$scriptdir:$libexecdir:$PATH"
+
+if [[ -t 1 ]] && type -p diff-colorize >/dev/null; then
+    diff -u "$@" | diff-colorize
+else
+    diff -u "$@"
+fi

pyflyby-1.10.4.data/scripts/reformat-imports

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""
+reformat-imports *.py
+reformat-imports < foo.py
+
+Reformats the top-level 'import' blocks within the python module/script.
+
+"""
+# pyflyby/reformat-imports
+# Copyright (C) 2011, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+from   pyflyby._cmdline         import parse_args, process_actions
+from   pyflyby._imports2s       import reformat_import_statements
+
+
+def main():
+    options, args = parse_args(
+        import_format_params=True, modify_action_params=True)
+    def modify(x):
+        return reformat_import_statements(x, params=options.params)
+    process_actions(args, options.actions, modify)
+
+
+if __name__ == '__main__':
+    main()

pyflyby-1.10.4.data/scripts/replace-star-imports

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""
+replace-star-imports *.py
+replace-star-imports < foo.py
+
+Replaces::
+  from foo.bar import *
+with::
+  from foo.bar import (f1, f2, ...)
+
+Note: This actually executes imports.
+
+If filenames are given on the command line, rewrites them.  Otherwise, if
+stdin is not a tty, read from stdin and write to stdout.
+
+Only top-level import statements are touched.
+
+"""
+# pyflyby/replace-star-imports
+# Copyright (C) 2012, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+from   pyflyby._cmdline         import parse_args, process_actions
+from   pyflyby._imports2s       import replace_star_imports
+
+
+def main():
+    options, args = parse_args(
+        import_format_params=True, modify_action_params=True)
+    def modify(x):
+        return replace_star_imports(x, params=options.params)
+    process_actions(args, options.actions, modify)
+
+
+if __name__ == '__main__':
+    main()