pyflyby 1.9.4__py3-none-any.whl

pyflyby-1.9.4.data/data/share/doc/pyflyby/LICENSE.txt

@@ -0,0 +1,23 @@
+Pyflyby: Copyright (c) 2011, 2012, 2013, 2014, 2015 Karl Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+Docxref.py includes code derived from Epydoc, which is also distributed under
+the same MIT license.

pyflyby-1.9.4.data/data/share/doc/pyflyby/TODO.txt

@@ -0,0 +1,115 @@
+
+- Support removing imports at any level, not just top-level.
+- Support adding imports inside functions.  Guess that an import should be
+  local if there were any other local imports from the same module.
+- Allow options in .pyflyby files such as __options__ = '--uniform'
+- Allow an option in .pyflyby files that means "stop processing further
+  database files"
+- Heuristically guess alignment style from existing code
+- Grouping: Teach tidy-imports to canonicalize import groups.  3 possiblities:
+  (1) Follow PEP8 standard library imports, then third-party imports, then
+  local app imports. http://legacy.python.org/dev/peps/pep-0008/#imports. Best
+  default. (2) The Eclipse way: for each top-level package, if there is more
+  than one import statement, then make those a group.  (3) User-configured
+  grouping.
+- Use rope?
+- Allow comments in a file to specify imports that shouldn't be removed,
+  including "*" to mean don't-remove-any.
+- Allow a comment in the file to specify alignment options.
+- Guess the module name for relative imports.
+- Preserve comments on import lines (as much as possible anyway - may need to
+  make them standalone comments).
+- Preserve line ending style (\r\n).
+- Merge share/pyflyby/*.py into a single file.
+- Make sure etc/pyflyby works for both systemwide installation and virtualenv
+  installation
+- Consider making the default database file more like a sample file that the
+  user is instructed to cp to ~/.pyflyby.  What about existing users of older
+  versions?  Perhaps have an auto-upgrade feature
+- Refactor autoimport.py to share more with rest of pyflyby, esp AST parsing.
+- Consider __mandatory_imports -= [...] instead of __forget_imports__=[...].
+- Packaging:
+    - Make 'install' put etc in /etc outside egg (but inside virtualenv is
+      ok).  Or think about the right way to do config files otherwise.
+    - Avoid compiling etc files to .pyc.
+    - Make bin/tidy-imports work out of the box after sdist+unpack.  Currently
+      sdist doesn't include the bin/pyflyby symlink.
+    - Make zip-safe/PEP308 compliant; use pkg_resources (if possible) instead
+      of __file__.
+- If fail to import something, remove it (and children) from known imports.
+- Autopython script
+- Make naming consistent: auto_importer vs autoimporter
+
+
+- Add pretty-printing parameter --groupimports=manual|pep8|java, new default
+  pep8.
+- Pep8 grouping:
+    - stdlib, then third-party libs, then first-party libs
+    - guess whether the current file is in the same package as an
+      import by checking if imported_pkg.split(".")[0] in filename.split("/").
+    - But how do we distinguish some random local module from third-party
+      libraries?  Import it and check if path is in sys.path excluding current
+      dir?  Not satisfying but can't think of anything better.
+    - stdlib before third-party libs.  Need a list of stdlibs.
+      I guess we should include e.g. argparse regardless of the python version,
+      since we don't want the grouping to change depending on python version.
+      Maybe just use a (cogged) hardcoded list of modules.
+
+- pyflyby_path importdb: require that components start with "/" or "./" or
+  ".../"; i.e. don't allow "foo/bar"; tell user to use "./foo/bar" if that's
+  what he wants.  Test case.
+- Pyflyby_path: make sure that empty strings are ignored, not treated as ".".
+  Test case.
+- py --safe: pyflyby_path=":" (not empty string, because that means "use
+  default")
+
+- Allow non-imports in import db?  Warn or allow silently?  Indicate mode
+  somehow? We want to allow setting pyflyby_path to the directory of code and
+  use it without having to maintain an importdb.  But don't make regular
+  .pyflyby databases sloppy.
+
+- collect-exports: new mode that parses file and enumerates "stores", instead
+  of executing code.
+
+- Unify collect-imports/collect-exports/collect-exports-from-stores into a
+  single script with a mode argument.  Also parameters for whether to include
+  things imported from submodules (default on) and whether to include things
+  imported from other packages (default off).
+
+- Add tidy-imports, etc to py
+
+- Merge contents of all scripts into modules, and use setup.py entry_points.
+  Keep stub scripts in bin directory only for non-installed usage.
+
+- Support pypy.  It seems to already work fine in casual tests, but tox and
+  maybe setup.py need tweaking
+
+- Transforms: support 'from a import b' => 'from c import d' (plus global
+  replace b=>d) in addition to 'from a import b' => 'from c import d as b'
+
+- Make tidy-imports support detecting that print_function is necessary but
+  missing, and add it.
+
+- Tidy-imports for notebooks: add all necessary imports to cells (either at
+  the top or per cell)
+
+- Fix issue where properties get evaluated by pyflyby and then again by
+  ipython.  E.g. repeated print output in test_complete_symbol_nonmodule_1.
+  We can't avoid pyflyby evaluating the property.  But is there some way to
+  intercept ipython's subsequent evaluation and reuse the same result?
+
+- Spyder: Fix pyflyby output coming during tab completion messing up the
+  display.  May need to fix in Spyder itself.
+
+- Handle comments between concatenate strings, e.g.: 'myvar =
+  ("xx"\n#blah\n"yy")', e.g. in test_interactive.py.
+
+- Function & interactive command to automatically add interactively-typed
+  imports to ~/.pyflyby.
+
+- Store all interactively-typed imports to an area that can be consulted to
+  print out but don't automatically use
+
+- Integration with search pydoc index for where to get import - but don't use
+  it automatically, just print it out and ask user if he wants to add it to
+  database

pyflyby-1.9.4.data/data/share/doc/pyflyby/testing.txt

@@ -0,0 +1,13 @@
+
+./setup.py test
+
+py.test --doctest-modules lib tests
+
+py.test tests/test_foo.py -v -k TAG
+py.test --pdb -k TAG
+
+py.test -n NUM    # requires pytest-xdist plugin
+
+
+tox
+tox -e py27-ipy23

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

@@ -0,0 +1,108 @@
+
+(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)))
+    (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.9.4.data/scripts/collect-exports

@@ -0,0 +1,76 @@
+#!python
+"""
+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.9.4.data/scripts/collect-imports

@@ -0,0 +1,58 @@
+#!python
+"""
+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.9.4.data/scripts/find-import

@@ -0,0 +1,38 @@
+#!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.9.4.data/scripts/list-bad-xrefs

@@ -0,0 +1,34 @@
+#!python
+"""
+Usage: list-bad-xrefs modules... filenames...
+
+Prints the bad docstring cross-references in the given modules.
+
+Similar to running C{epydoc -v}, but:
+  - The output is organized so that it is easy to identify the code needing
+    fixing.
+  - If a cross-reference is to an external module, its references are included
+    automatically.
+"""
+# pyflyby/list-bad-xrefs
+# Copyright (C) 2011, 2014 Karl Chen.
+# License: MIT http://opensource.org/licenses/MIT
+
+
+from   pyflyby._cmdline         import parse_args, syntax
+from   pyflyby._docxref         import find_bad_doc_cross_references
+
+
+def main():
+    options, args = parse_args()
+    if not args:
+        syntax()
+    for rec in find_bad_doc_cross_references(args):
+        module, linenos, container_name, identifier = rec
+        for lineno in linenos or ["?"]:
+            print("%s:%s: undefined docstring cross-reference in %s: %s" % (
+                module.filename, lineno, container_name, identifier))
+
+
+if __name__ == '__main__':
+    main()

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

@@ -0,0 +1,34 @@
+#!python
+"""
+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.9.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.9.4.data/scripts/reformat-imports

@@ -0,0 +1,27 @@
+#!python
+"""
+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.9.4.data/scripts/replace-star-imports

@@ -0,0 +1,37 @@
+#!python
+"""
+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()