diff --git a/.gitignore b/.gitignore index d986511..ef07955 100755 --- a/.gitignore +++ b/.gitignore @@ -2,4 +2,9 @@ \#*\# *.log .#* -emacs/.emacs.d/elpa/* \ No newline at end of file +emacs/.emacs.d/ac-comphist.dat +emacs/.emacs.d/anaconda-mode/* +emacs/.emacs.d/auto-save-list/* +emacs/.emacs.d/elpa/* +emacs/.emacs.d/recentf +emacs/.emacs.d/tramp \ No newline at end of file diff --git a/emacs/.emacs.d/ac-comphist.dat b/emacs/.emacs.d/ac-comphist.dat deleted file mode 100644 index 8bb50d0..0000000 --- a/emacs/.emacs.d/ac-comphist.dat +++ /dev/null @@ -1,4 +0,0 @@ -((("wird" . - [2 0 0 0]) - ("defun" . - [0 0 0 1 0]))) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/DESCRIPTION.rst b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/DESCRIPTION.rst deleted file mode 100644 index e0f03bb..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/DESCRIPTION.rst +++ /dev/null @@ -1,305 +0,0 @@ - -.. |travis| image:: https://img.shields.io/travis/proofit404/anaconda-mode.svg?style=flat-square - :target: https://travis-ci.org/proofit404/anaconda-mode - :alt: Build Status - -.. |coveralls| image:: https://img.shields.io/coveralls/proofit404/anaconda-mode.svg?style=flat-square - :target: https://coveralls.io/r/proofit404/anaconda-mode - :alt: Coverage Status - -.. |requires| image:: https://img.shields.io/requires/github/proofit404/anaconda-mode.svg?style=flat-square - :target: https://requires.io/github/proofit404/anaconda-mode/requirements - :alt: Requirements Status - -.. |melpa| image:: http://melpa.org/packages/anaconda-mode-badge.svg - :target: http://melpa.org/#/anaconda-mode - :alt: Melpa - -.. |melpa-stable| image:: http://stable.melpa.org/packages/anaconda-mode-badge.svg - :target: http://stable.melpa.org/#/anaconda-mode - :alt: Melpa Stable - -.. image:: static/logo.png - :align: right - :alt: Logo - -=============== - Anaconda mode -=============== - -|travis| |coveralls| |requires| |melpa| |melpa-stable| - -Code navigation, documentation lookup and completion for Python. - -.. figure:: static/completion.png - -.. figure:: static/reference.png - - -Features --------- -Anaconda mode provides the following features - -* context-sensitive code completion -* jump to definitions -* find references -* view documentation -* virtual environment -* eldoc mode -* all this stuff inside vagrant and remote hosts - -Supported Python Versions -------------------------- -2.6, 2.7, 3.3, 3.4 - -Installation ------------- - -To use this package you need to install ``setuptools``. - -package.el -`````````` - -All you need to do is install the package from Melpa_:: - - M-x package-install RET anaconda-mode RET - -Manual -`````` - -Clone this repository somewhere and add this directory to your -``load-path``. - -Prelude -``````` - -``anaconda-mode`` is included in the `Emacs Prelude`_ distribution. You -can use it as well. Look at the ``prelude-python`` module to see more -details. - -Spacemacs -````````` - -``anaconda-mode`` is included in the Spacemacs_ distribution. You can use -it as well. Look at the ``python`` language layer to see more details. - -Configuration -------------- - -You can automatically enable ``anaconda-mode`` in all python buffers -with following code in your configuration: - -.. code:: lisp - - (add-hook 'python-mode-hook 'anaconda-mode) - -ElDoc -````` - -``anaconda-eldoc-mode`` provide document function to ``eldoc-mode``. All -you need is to enable ``anaconda-eldoc-mode`` in addition to the previous setup. - -.. code:: lisp - - (add-hook 'python-mode-hook 'anaconda-eldoc-mode) - -Usage ------ - -To start a completion press ``C-M-i``. This is the standard emacs binding -for ``complete-at-point`` function. You can use company-mode_ with -company-anaconda_ backend to get more intelligent ui. Or -auto-complete-mode_ with ac-anaconda_ as a last try. - -Interactive commands -```````````````````` - -Here is a list of interactive commands available with anaconda-mode - -========== ============================== -Keybinding Description -========== ============================== -C-M-i anaconda-mode-complete -M-. anaconda-mode-find-definitions -M-, anaconda-mode-find-assignments -M-r anaconda-mode-find-references -M-* anaconda-mode-go-back -M-? anaconda-mode-show-doc -========== ============================== - -If multiple candidates are found for definitions, assignments or usages, -you'll see an advanced anaconda navigator buffer. - -PYTHONPATH -`````````` - -You can add your project to the Emacs ``PYTHONPATH``. If you store project -dependencies somewhere on your machine, you can add them as well. - -.. code:: lisp - - (add-to-list 'python-shell-extra-pythonpaths "/path/to/the/project") - (add-to-list 'python-shell-extra-pythonpaths "/path/to/the/dependency") - -Virtual environment -``````````````````` - -Use a virtual environment to isolate your project dependencies from -others on the system. You can additionally install your project in an editable -mode in the virtual environment. This will improve search functionality. -Then activate this virtual environment inside Emacs. - -:: - - M-x pythonic-activate RET /path/to/virtualenv RET - -Also you can use `pyenv-mode`_ or similar package to hold virtual -environment in actual state. - -Each action above applies to ``anaconda-mode`` immediately. The next -``anaconda-mode`` command you call will use this environment for -search completion candidates. - -Tramp -````` - -It's possible to use anaconda-mode on a remote server when you connect -to it using tramp. Anaconda-mode can search for completion candidates -and all other stuff on remote server while you're running Emacs locally. -First of all open interesting remote file. - -:: - - C-x C-f /ssh:remote_host:project/__init__.py RET - -After tramp successfully connects and you see actual buffer -content, activate the remote virtual environment. - -:: - - M-x pythoninc-activate RET /ssh:remote_host:/home/user/venv RET - -Now any anaconda-mode command will use ``/home/user/venv/bin/python`` -interpreter running on ``remote_host`` over ssh. If you don't use the -virtual environment remotely then you have an option to specify the remote -interpreter directly. - -.. code:: lisp - - (setq python-shell-interpreter "/ssh:remote_host:/usr/bin/python") - -It is important to remember that ``remote_host`` must be a real host -name or an IP address. SSH aliases not allowed to be used with -anaconda-mode. Also port 9000 on the remote host should be open to -incoming connections from your local machine. A final note about project scope: -all kinds of searching from inside the -virtual environment are available from any buffer. However searching inside your -project is available only if you open it on the same machine as the -interpreter. - -Vagrant -``````` - -You can get all the intelligent features of anaconda-mode with virtual -environments deployed on your vagrant box. Fire up the vagrant machine as usual. -The easiest way to handle authentication is to copy your public ssh key to the -vagrant box. - -:: - - ssh-copy-id vagrant@localhost -p 2222 - -Now open your project inside the vagrant box. - -:: - - C-x C-f /ssh:vagrant@localhost#2222:/vagrant/polls/views.py - -Check the ``*anaconda-mode*`` buffer for the port number, and forward that port -from vagrant. - -:: - - ssh -nNT vagrant@localhost -p 2222 -L :localhost: - -Then activate your project environment installed inside vagrant. - -:: - - M-x pythonic-activate RET /ssh:vagrant@localhost#2222:/vagrant/polls/venv RET - -Now you are ready to go. If you have random connection errors during interaction -with running server, try replacing the host name with the IP address, for example, -``localhost`` with ``127.0.0.1``. - -Implementation details ----------------------- - -Anaconda mode comes with ``anaconda_mode.py`` server. This server -allows you to use the jedi_ python library over jsonrpc api. The server chooses -first available port starting from 9000. Anaconda mode will run this -server automatically on first call of any anaconda-mode command. - -This means that completion results and reference searches depend on your -project installation. - -Bug Reports ------------ - -Please attach ``*anaconda-mode*`` buffer content to every created -issue. - -Issues ------- - -AttributeError and KeyError randomly happens -```````````````````````````````````````````` - -These kinds of problems were reported with jedi 0.9 version. (This -error may occur in Spacemacs or any other usage). You can try to -downgrade jedi version down to 0.8. - -:: - - M-: (dired (anaconda-mode-server-directory)) RET - M-! rm -rf jedi* RET - M-! pip install "jedi<0.9" -t . RET - -After you saw the jedi version changed to 0.8 in the dired window, you -have to refresh Emacs to make it work right away. You can either -restart Emacs or kill the ``*anaconda-mode*`` buffer. - -Contributions -------------- - -Are very welcome. But any significant change has to be accompanied -with tests, both for Emacs Lisp and Python code. To run the test -suite, call: - -.. code:: shell - - tox - -Thanks ------- - -* Dmitry Gutov **@dgutov** -* Bo Lin **@sadboy** -* Vasilij Schneidermann **@wasamasa** -* Fredrik Bergroth **@fbergroth** -* Fabio Corneti **@fabiocorneti** -* Tom Davis **@tdavis** -* Sviridov Alexander **@sviridov** -* Mario Rodas **@marsam** - -.. _Melpa: http://melpa.milkbox.net/ -.. _pyenv-mode: https://github.com/proofit404/pyenv-mode -.. _jedi: http://jedi.jedidjah.ch/en/latest/ -.. _emacs prelude: https://github.com/bbatsov/prelude -.. _spacemacs: https://github.com/syl20bnr/spacemacs -.. _company-mode: http://company-mode.github.io/ -.. _company-anaconda: https://github.com/proofit404/company-anaconda -.. _auto-complete-mode: https://github.com/auto-complete/auto-complete -.. _ac-anaconda: https://github.com/proofit404/ac-anaconda - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/PKG-INFO b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/PKG-INFO deleted file mode 100644 index 84b55da..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/PKG-INFO +++ /dev/null @@ -1,332 +0,0 @@ -Metadata-Version: 2.0 -Name: anaconda-mode -Version: 0.1.9 -Summary: Code navigation, documentation lookup and completion for Python. -Home-page: https://github.com/proofit404/anaconda-mode -Author: Artem Malyshev -Author-email: proofit404@gmail.com -License: GPL3 -Description-Content-Type: UNKNOWN -Platform: any -Classifier: Development Status :: 4 - Beta -Classifier: Environment :: Console -Classifier: Intended Audience :: Developers -Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3) -Classifier: Programming Language :: Python :: 2 -Classifier: Programming Language :: Python :: 2.6 -Classifier: Programming Language :: Python :: 2.7 -Classifier: Programming Language :: Python :: 3 -Classifier: Programming Language :: Python :: 3.2 -Classifier: Programming Language :: Python :: 3.3 -Classifier: Programming Language :: Python :: 3.4 -Classifier: Programming Language :: Python :: 3.5 -Classifier: Topic :: Text Editors -Classifier: Topic :: Text Editors :: Emacs -Requires-Dist: jedi (>=0.11) -Requires-Dist: service-factory (>=0.1.5) - - -.. |travis| image:: https://img.shields.io/travis/proofit404/anaconda-mode.svg?style=flat-square - :target: https://travis-ci.org/proofit404/anaconda-mode - :alt: Build Status - -.. |coveralls| image:: https://img.shields.io/coveralls/proofit404/anaconda-mode.svg?style=flat-square - :target: https://coveralls.io/r/proofit404/anaconda-mode - :alt: Coverage Status - -.. |requires| image:: https://img.shields.io/requires/github/proofit404/anaconda-mode.svg?style=flat-square - :target: https://requires.io/github/proofit404/anaconda-mode/requirements - :alt: Requirements Status - -.. |melpa| image:: http://melpa.org/packages/anaconda-mode-badge.svg - :target: http://melpa.org/#/anaconda-mode - :alt: Melpa - -.. |melpa-stable| image:: http://stable.melpa.org/packages/anaconda-mode-badge.svg - :target: http://stable.melpa.org/#/anaconda-mode - :alt: Melpa Stable - -.. image:: static/logo.png - :align: right - :alt: Logo - -=============== - Anaconda mode -=============== - -|travis| |coveralls| |requires| |melpa| |melpa-stable| - -Code navigation, documentation lookup and completion for Python. - -.. figure:: static/completion.png - -.. figure:: static/reference.png - - -Features --------- -Anaconda mode provides the following features - -* context-sensitive code completion -* jump to definitions -* find references -* view documentation -* virtual environment -* eldoc mode -* all this stuff inside vagrant and remote hosts - -Supported Python Versions -------------------------- -2.6, 2.7, 3.3, 3.4 - -Installation ------------- - -To use this package you need to install ``setuptools``. - -package.el -`````````` - -All you need to do is install the package from Melpa_:: - - M-x package-install RET anaconda-mode RET - -Manual -`````` - -Clone this repository somewhere and add this directory to your -``load-path``. - -Prelude -``````` - -``anaconda-mode`` is included in the `Emacs Prelude`_ distribution. You -can use it as well. Look at the ``prelude-python`` module to see more -details. - -Spacemacs -````````` - -``anaconda-mode`` is included in the Spacemacs_ distribution. You can use -it as well. Look at the ``python`` language layer to see more details. - -Configuration -------------- - -You can automatically enable ``anaconda-mode`` in all python buffers -with following code in your configuration: - -.. code:: lisp - - (add-hook 'python-mode-hook 'anaconda-mode) - -ElDoc -````` - -``anaconda-eldoc-mode`` provide document function to ``eldoc-mode``. All -you need is to enable ``anaconda-eldoc-mode`` in addition to the previous setup. - -.. code:: lisp - - (add-hook 'python-mode-hook 'anaconda-eldoc-mode) - -Usage ------ - -To start a completion press ``C-M-i``. This is the standard emacs binding -for ``complete-at-point`` function. You can use company-mode_ with -company-anaconda_ backend to get more intelligent ui. Or -auto-complete-mode_ with ac-anaconda_ as a last try. - -Interactive commands -```````````````````` - -Here is a list of interactive commands available with anaconda-mode - -========== ============================== -Keybinding Description -========== ============================== -C-M-i anaconda-mode-complete -M-. anaconda-mode-find-definitions -M-, anaconda-mode-find-assignments -M-r anaconda-mode-find-references -M-* anaconda-mode-go-back -M-? anaconda-mode-show-doc -========== ============================== - -If multiple candidates are found for definitions, assignments or usages, -you'll see an advanced anaconda navigator buffer. - -PYTHONPATH -`````````` - -You can add your project to the Emacs ``PYTHONPATH``. If you store project -dependencies somewhere on your machine, you can add them as well. - -.. code:: lisp - - (add-to-list 'python-shell-extra-pythonpaths "/path/to/the/project") - (add-to-list 'python-shell-extra-pythonpaths "/path/to/the/dependency") - -Virtual environment -``````````````````` - -Use a virtual environment to isolate your project dependencies from -others on the system. You can additionally install your project in an editable -mode in the virtual environment. This will improve search functionality. -Then activate this virtual environment inside Emacs. - -:: - - M-x pythonic-activate RET /path/to/virtualenv RET - -Also you can use `pyenv-mode`_ or similar package to hold virtual -environment in actual state. - -Each action above applies to ``anaconda-mode`` immediately. The next -``anaconda-mode`` command you call will use this environment for -search completion candidates. - -Tramp -````` - -It's possible to use anaconda-mode on a remote server when you connect -to it using tramp. Anaconda-mode can search for completion candidates -and all other stuff on remote server while you're running Emacs locally. -First of all open interesting remote file. - -:: - - C-x C-f /ssh:remote_host:project/__init__.py RET - -After tramp successfully connects and you see actual buffer -content, activate the remote virtual environment. - -:: - - M-x pythoninc-activate RET /ssh:remote_host:/home/user/venv RET - -Now any anaconda-mode command will use ``/home/user/venv/bin/python`` -interpreter running on ``remote_host`` over ssh. If you don't use the -virtual environment remotely then you have an option to specify the remote -interpreter directly. - -.. code:: lisp - - (setq python-shell-interpreter "/ssh:remote_host:/usr/bin/python") - -It is important to remember that ``remote_host`` must be a real host -name or an IP address. SSH aliases not allowed to be used with -anaconda-mode. Also port 9000 on the remote host should be open to -incoming connections from your local machine. A final note about project scope: -all kinds of searching from inside the -virtual environment are available from any buffer. However searching inside your -project is available only if you open it on the same machine as the -interpreter. - -Vagrant -``````` - -You can get all the intelligent features of anaconda-mode with virtual -environments deployed on your vagrant box. Fire up the vagrant machine as usual. -The easiest way to handle authentication is to copy your public ssh key to the -vagrant box. - -:: - - ssh-copy-id vagrant@localhost -p 2222 - -Now open your project inside the vagrant box. - -:: - - C-x C-f /ssh:vagrant@localhost#2222:/vagrant/polls/views.py - -Check the ``*anaconda-mode*`` buffer for the port number, and forward that port -from vagrant. - -:: - - ssh -nNT vagrant@localhost -p 2222 -L :localhost: - -Then activate your project environment installed inside vagrant. - -:: - - M-x pythonic-activate RET /ssh:vagrant@localhost#2222:/vagrant/polls/venv RET - -Now you are ready to go. If you have random connection errors during interaction -with running server, try replacing the host name with the IP address, for example, -``localhost`` with ``127.0.0.1``. - -Implementation details ----------------------- - -Anaconda mode comes with ``anaconda_mode.py`` server. This server -allows you to use the jedi_ python library over jsonrpc api. The server chooses -first available port starting from 9000. Anaconda mode will run this -server automatically on first call of any anaconda-mode command. - -This means that completion results and reference searches depend on your -project installation. - -Bug Reports ------------ - -Please attach ``*anaconda-mode*`` buffer content to every created -issue. - -Issues ------- - -AttributeError and KeyError randomly happens -```````````````````````````````````````````` - -These kinds of problems were reported with jedi 0.9 version. (This -error may occur in Spacemacs or any other usage). You can try to -downgrade jedi version down to 0.8. - -:: - - M-: (dired (anaconda-mode-server-directory)) RET - M-! rm -rf jedi* RET - M-! pip install "jedi<0.9" -t . RET - -After you saw the jedi version changed to 0.8 in the dired window, you -have to refresh Emacs to make it work right away. You can either -restart Emacs or kill the ``*anaconda-mode*`` buffer. - -Contributions -------------- - -Are very welcome. But any significant change has to be accompanied -with tests, both for Emacs Lisp and Python code. To run the test -suite, call: - -.. code:: shell - - tox - -Thanks ------- - -* Dmitry Gutov **@dgutov** -* Bo Lin **@sadboy** -* Vasilij Schneidermann **@wasamasa** -* Fredrik Bergroth **@fbergroth** -* Fabio Corneti **@fabiocorneti** -* Tom Davis **@tdavis** -* Sviridov Alexander **@sviridov** -* Mario Rodas **@marsam** - -.. _Melpa: http://melpa.milkbox.net/ -.. _pyenv-mode: https://github.com/proofit404/pyenv-mode -.. _jedi: http://jedi.jedidjah.ch/en/latest/ -.. _emacs prelude: https://github.com/bbatsov/prelude -.. _spacemacs: https://github.com/syl20bnr/spacemacs -.. _company-mode: http://company-mode.github.io/ -.. _company-anaconda: https://github.com/proofit404/company-anaconda -.. _auto-complete-mode: https://github.com/auto-complete/auto-complete -.. _ac-anaconda: https://github.com/proofit404/ac-anaconda - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/RECORD b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/RECORD deleted file mode 100644 index 3f9ba3f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/RECORD +++ /dev/null @@ -1,7 +0,0 @@ -anaconda_mode.py,sha256=e9O9YfhtxQEBpVkvNltJlk80mvTpm5kCWdWmIPB8FI4,2579 -anaconda_mode-0.1.9.dist-info/DESCRIPTION.rst,sha256=SQfFskNefB5PKjFi_zHFVik3kHWXbb941YO_udbU0V0,8805 -anaconda_mode-0.1.9.dist-info/METADATA,sha256=cKsFgEY0BgmpqR6z3Vu-2axGlEGDIVb_O53GhpdASvE,9854 -anaconda_mode-0.1.9.dist-info/RECORD,, -anaconda_mode-0.1.9.dist-info/WHEEL,sha256=8Lm45v9gcYRm70DrgFGVe4WsUtUMi1_0Tso1hqPGMjA,92 -anaconda_mode-0.1.9.dist-info/metadata.json,sha256=BJY77RH3AfXAJ1IE7ZIOv9DRBM60wtdSlI3OCEIWk8E,1178 -anaconda_mode-0.1.9.dist-info/top_level.txt,sha256=L8Fh-IKHfPsLM8slR8CSTKc7TI1BiVzAC5nR-tLkGLM,14 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/WHEEL b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/WHEEL deleted file mode 100644 index 6261a26..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/WHEEL +++ /dev/null @@ -1,5 +0,0 @@ -Wheel-Version: 1.0 -Generator: bdist_wheel (0.30.0) -Root-Is-Purelib: true -Tag: py3-none-any - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/metadata.json b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/metadata.json deleted file mode 100644 index 8d4856d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"classifiers": ["Development Status :: 4 - Beta", "Environment :: Console", "Intended Audience :: Developers", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.2", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Topic :: Text Editors", "Topic :: Text Editors :: Emacs"], "description_content_type": "UNKNOWN", "extensions": {"python.details": {"contacts": [{"email": "proofit404@gmail.com", "name": "Artem Malyshev", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/proofit404/anaconda-mode"}}}, "extras": [], "generator": "bdist_wheel (0.30.0)", "license": "GPL3", "metadata_version": "2.0", "name": "anaconda-mode", "platform": "any", "run_requires": [{"requires": ["jedi (>=0.11)", "service-factory (>=0.1.5)"]}], "summary": "Code navigation, documentation lookup and completion for Python.", "version": "0.1.9"} \ No newline at end of file diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/requires.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/requires.txt deleted file mode 100644 index 6a1ea29..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/requires.txt +++ /dev/null @@ -1,2 +0,0 @@ -jedi>=0.11 -service-factory>=0.1.5 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/top_level.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/top_level.txt deleted file mode 100644 index d692d49..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/EGG-INFO/top_level.txt +++ /dev/null @@ -1 +0,0 @@ -anaconda_mode diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/__pycache__/anaconda_mode.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/__pycache__/anaconda_mode.cpython-36.pyc deleted file mode 100644 index 4fbd627..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/__pycache__/anaconda_mode.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/anaconda_mode.py b/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/anaconda_mode.py deleted file mode 100644 index 86ff995..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/anaconda_mode-0.1.9-py3.6.egg/anaconda_mode.py +++ /dev/null @@ -1,110 +0,0 @@ -""" - anaconda_mode - ~~~~~~~~~~~~~ - - This is anaconda_mode autocompletion server. - - :copyright: (c) 2013-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, - division, - print_function, - unicode_literals, -) - -import sys -from functools import wraps - -from jedi import Script -from service_factory import service_factory - - -def script_method(f): - """Create jedi.Script instance and apply f to it.""" - - @wraps(f) - def wrapper(source, line, column, path): - return f(Script(source, line, column, path)) - - return wrapper - - -def process_definitions(f): - """Call f and convert it result into json dumpable format.""" - - @wraps(f) - def wrapper(script): - - return [{'name': definition.name, - 'type': definition.type, - 'module-name': definition.module_name, - 'module-path': definition.module_path, - 'line': definition.line, - 'column': definition.column, - 'docstring': definition.docstring(), - 'description': definition.description, - 'full-name': definition.full_name} - for definition in f(script)] - - return wrapper - - -@script_method -@process_definitions -def complete(script): - """Select auto-complete candidates for source position.""" - - return script.completions() - - -@script_method -@process_definitions -def goto_definitions(script): - """Get definitions for thing under cursor.""" - - return script.goto_definitions() - - -@script_method -@process_definitions -def goto_assignments(script): - """Get assignments for thing under cursor.""" - - return script.goto_assignments() - - -@script_method -@process_definitions -def usages(script): - """Get usage information for thing under cursor.""" - - return script.usages() - - -@script_method -def eldoc(script): - """Return eldoc format documentation string or ''.""" - - signatures = script.call_signatures() - if len(signatures) == 1: - signature = signatures[0] - return { - 'name': signature.name, - 'index': signature.index, - # NOTE: Remove 'param ' prefix from each description. - 'params': [param.description[6:] for param in signature.params] - } - - -app = [complete, goto_definitions, goto_assignments, usages, eldoc] - - -def main(args): - host = args[0] if len(args) == 1 else '127.0.0.1' - service_factory(app, host, 0, 'anaconda_mode port {port}') - -if __name__ == '__main__': - main(sys.argv[1:]) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/easy-install.pth b/emacs/.emacs.d/anaconda-mode/0.1.9/easy-install.pth deleted file mode 100644 index 567b254..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/easy-install.pth +++ /dev/null @@ -1,4 +0,0 @@ -./anaconda_mode-0.1.9-py3.6.egg -./service_factory-0.1.5-py3.6.egg -./jedi-0.11.1-py3.6.egg -./parso-0.1.1-py3.6.egg diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/DESCRIPTION.rst b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/DESCRIPTION.rst deleted file mode 100644 index 7384291..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/DESCRIPTION.rst +++ /dev/null @@ -1,306 +0,0 @@ -################################################################### -Jedi - an awesome autocompletion/static analysis library for Python -################################################################### - -.. image:: https://secure.travis-ci.org/davidhalter/jedi.png?branch=master - :target: http://travis-ci.org/davidhalter/jedi - :alt: Travis-CI build status - -.. image:: https://coveralls.io/repos/davidhalter/jedi/badge.png?branch=master - :target: https://coveralls.io/r/davidhalter/jedi - :alt: Coverage Status - - -*If you have specific questions, please add an issue or ask on* `stackoverflow -`_ *with the label* ``python-jedi``. - - -Jedi is a static analysis tool for Python that can be used in IDEs/editors. Its -historic focus is autocompletion, but does static analysis for now as well. -Jedi is fast and is very well tested. It understands Python on a deeper level -than all other static analysis frameworks for Python. - -Jedi has support for two different goto functions. It's possible to search for -related names and to list all names in a Python file and infer them. Jedi -understands docstrings and you can use Jedi autocompletion in your REPL as -well. - -Jedi uses a very simple API to connect with IDE's. There's a reference -implementation as a `VIM-Plugin `_, -which uses Jedi's autocompletion. We encourage you to use Jedi in your IDEs. -It's really easy. - -Jedi can currently be used with the following editors/projects: - -- Vim (jedi-vim_, YouCompleteMe_, deoplete-jedi_, completor.vim_) -- Emacs (Jedi.el_, company-mode_, elpy_, anaconda-mode_, ycmd_) -- Sublime Text (SublimeJEDI_ [ST2 + ST3], anaconda_ [only ST3]) -- TextMate_ (Not sure if it's actually working) -- Kate_ version 4.13+ supports it natively, you have to enable it, though. [`proof - `_] -- Atom_ (autocomplete-python-jedi_) -- SourceLair_ -- `GNOME Builder`_ (with support for GObject Introspection) -- `Visual Studio Code`_ (via `Python Extension `_) -- Gedit (gedi_) -- wdb_ - Web Debugger -- `Eric IDE`_ (Available as a plugin) -- `Ipython 6.0.0+ `_ - -and many more! - - -Here are some pictures taken from jedi-vim_: - -.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png - -Completion for almost anything (Ctrl+Space). - -.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png - -Display of function/class bodies, docstrings. - -.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png - -Pydoc support (Shift+k). - -There is also support for goto and renaming. - -Get the latest version from `github `_ -(master branch should always be kind of stable/working). - -Docs are available at `https://jedi.readthedocs.org/en/latest/ -`_. Pull requests with documentation -enhancements and/or fixes are awesome and most welcome. Jedi uses `semantic -versioning `_. - - -Installation -============ - - pip install jedi - -Note: This just installs the Jedi library, not the editor plugins. For -information about how to make it work with your editor, refer to the -corresponding documentation. - -You don't want to use ``pip``? Please refer to the `manual -`_. - - -Feature Support and Caveats -=========================== - -Jedi really understands your Python code. For a comprehensive list what Jedi -understands, see: `Features -`_. A list of -caveats can be found on the same page. - -You can run Jedi on cPython 2.6, 2.7, 3.3, 3.4 or 3.5 but it should also -understand/parse code older than those versions. - -Tips on how to use Jedi efficiently can be found `here -`_. - -API ---- - -You can find the documentation for the `API here `_. - - -Autocompletion / Goto / Pydoc ------------------------------ - -Please check the API for a good explanation. There are the following commands: - -- ``jedi.Script.goto_assignments`` -- ``jedi.Script.completions`` -- ``jedi.Script.usages`` - -The returned objects are very powerful and really all you might need. - - -Autocompletion in your REPL (IPython, etc.) -------------------------------------------- - -Starting with Ipython `6.0.0` Jedi is a dependency of IPython. Autocompletion -in IPython is therefore possible without additional configuration. - -It's possible to have Jedi autocompletion in REPL modes - `example video `_. -This means that in Python you can enable tab completion in a `REPL -`_. - - -Static Analysis / Linter ------------------------- - -To do all forms of static analysis, please try to use ``jedi.names``. It will -return a list of names that you can use to infer types and so on. - -Linting is another thing that is going to be part of Jedi. For now you can try -an alpha version ``python -m jedi linter``. The API might change though and -it's still buggy. It's Jedi's goal to be smarter than classic linter and -understand ``AttributeError`` and other code issues. - - -Refactoring ------------ - -Jedi's parser would support refactoring, but there's no API to use it right -now. If you're interested in helping out here, let me know. With the latest -parser changes, it should be very easy to actually make it work. - - -Development -=========== - -There's a pretty good and extensive `development documentation -`_. - - -Testing -======= - -The test suite depends on ``tox`` and ``pytest``:: - - pip install tox pytest - -To run the tests for all supported Python versions:: - - tox - -If you want to test only a specific Python version (e.g. Python 2.7), it's as -easy as :: - - tox -e py27 - -Tests are also run automatically on `Travis CI -`_. - -For more detailed information visit the `testing documentation -`_ - - -Acknowledgements -================ - -- Takafumi Arakaki (@tkf) for creating a solid test environment and a lot of - other things. -- Danilo Bargen (@dbrgn) for general housekeeping and being a good friend :). -- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2 - (originally used in lib2to3). - - - -.. _jedi-vim: https://github.com/davidhalter/jedi-vim -.. _youcompleteme: http://valloric.github.io/YouCompleteMe/ -.. _deoplete-jedi: https://github.com/zchee/deoplete-jedi -.. _completor.vim: https://github.com/maralla/completor.vim -.. _Jedi.el: https://github.com/tkf/emacs-jedi -.. _company-mode: https://github.com/syohex/emacs-company-jedi -.. _elpy: https://github.com/jorgenschaefer/elpy -.. _anaconda-mode: https://github.com/proofit404/anaconda-mode -.. _ycmd: https://github.com/abingham/emacs-ycmd -.. _sublimejedi: https://github.com/srusskih/SublimeJEDI -.. _anaconda: https://github.com/DamnWidget/anaconda -.. _wdb: https://github.com/Kozea/wdb -.. _TextMate: https://github.com/lawrenceakka/python-jedi.tmbundle -.. _Kate: http://kate-editor.org -.. _Atom: https://atom.io/ -.. _autocomplete-python-jedi: https://atom.io/packages/autocomplete-python-jedi -.. _SourceLair: https://www.sourcelair.com -.. _GNOME Builder: https://wiki.gnome.org/Apps/Builder -.. _Visual Studio Code: https://code.visualstudio.com/ -.. _gedi: https://github.com/isamert/gedi -.. _Eric IDE: http://eric-ide.python-projects.org - - -.. :changelog: - -Changelog ---------- - -0.11.0 (2017-09-20) -+++++++++++++++++++ - -- Split Jedi's parser into a separate project called ``parso``. -- Avoiding side effects in REPL completion. -- Numpy docstring support should be much better. -- Moved the `settings.*recursion*` away, they are no longer usable. - -0.10.2 (2017-04-05) -+++++++++++++++++++ - -- Python Packaging sucks. Some files were not included in 0.10.1. - -0.10.1 (2017-04-05) -+++++++++++++++++++ - -- Fixed a few very annoying bugs. -- Prepared the parser to be factored out of Jedi. - -0.10.0 (2017-02-03) -+++++++++++++++++++ - -- Actual semantic completions for the complete Python syntax. -- Basic type inference for ``yield from`` PEP 380. -- PEP 484 support (most of the important features of it). Thanks Claude! (@reinhrst) -- Added ``get_line_code`` to ``Definition`` and ``Completion`` objects. -- Completely rewritten the type inference engine. -- A new and better parser for (fast) parsing diffs of Python code. - -0.9.0 (2015-04-10) -++++++++++++++++++ - -- The import logic has been rewritten to look more like Python's. There is now - an ``Evaluator.modules`` import cache, which resembles ``sys.modules``. -- Integrated the parser of 2to3. This will make refactoring possible. It will - also be possible to check for error messages (like compiling an AST would give) - in the future. -- With the new parser, the evaluation also completely changed. It's now simpler - and more readable. -- Completely rewritten REPL completion. -- Added ``jedi.names``, a command to do static analysis. Thanks to that - sourcegraph guys for sponsoring this! -- Alpha version of the linter. - - -0.8.1 (2014-07-23) -+++++++++++++++++++ - -- Bugfix release, the last release forgot to include files that improve - autocompletion for builtin libraries. Fixed. - -0.8.0 (2014-05-05) -+++++++++++++++++++ - -- Memory Consumption for compiled modules (e.g. builtins, sys) has been reduced - drastically. Loading times are down as well (it takes basically as long as an - import). -- REPL completion is starting to become usable. -- Various small API changes. Generally this release focuses on stability and - refactoring of internal APIs. -- Introducing operator precedence, which makes calculating correct Array - indices and ``__getattr__`` strings possible. - -0.7.0 (2013-08-09) -++++++++++++++++++ - -- Switched from LGPL to MIT license. -- Added an Interpreter class to the API to make autocompletion in REPL - possible. -- Added autocompletion support for namespace packages. -- Add sith.py, a new random testing method. - -0.6.0 (2013-05-14) -++++++++++++++++++ - -- Much faster parser with builtin part caching. -- A test suite, thanks @tkf. - -0.5 versions (2012) -+++++++++++++++++++ - -- Initial development. - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/PKG-INFO b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/PKG-INFO deleted file mode 100644 index 9364ecd..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/PKG-INFO +++ /dev/null @@ -1,337 +0,0 @@ -Metadata-Version: 2.0 -Name: jedi -Version: 0.11.1 -Summary: An autocompletion tool for Python that can be used for text editors. -Home-page: https://github.com/davidhalter/jedi -Author: David Halter -Author-email: davidhalter88@gmail.com -License: MIT -Keywords: python completion refactoring vim -Platform: any -Classifier: Development Status :: 4 - Beta -Classifier: Environment :: Plugins -Classifier: Intended Audience :: Developers -Classifier: License :: OSI Approved :: MIT License -Classifier: Operating System :: OS Independent -Classifier: Programming Language :: Python :: 2 -Classifier: Programming Language :: Python :: 2.6 -Classifier: Programming Language :: Python :: 2.7 -Classifier: Programming Language :: Python :: 3 -Classifier: Programming Language :: Python :: 3.3 -Classifier: Programming Language :: Python :: 3.4 -Classifier: Programming Language :: Python :: 3.5 -Classifier: Programming Language :: Python :: 3.6 -Classifier: Programming Language :: Python :: 3.7 -Classifier: Topic :: Software Development :: Libraries :: Python Modules -Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) -Classifier: Topic :: Utilities -Requires-Dist: parso (==0.1.1) -Provides-Extra: dev -Requires-Dist: docopt; extra == 'dev' - -################################################################### -Jedi - an awesome autocompletion/static analysis library for Python -################################################################### - -.. image:: https://secure.travis-ci.org/davidhalter/jedi.png?branch=master - :target: http://travis-ci.org/davidhalter/jedi - :alt: Travis-CI build status - -.. image:: https://coveralls.io/repos/davidhalter/jedi/badge.png?branch=master - :target: https://coveralls.io/r/davidhalter/jedi - :alt: Coverage Status - - -*If you have specific questions, please add an issue or ask on* `stackoverflow -`_ *with the label* ``python-jedi``. - - -Jedi is a static analysis tool for Python that can be used in IDEs/editors. Its -historic focus is autocompletion, but does static analysis for now as well. -Jedi is fast and is very well tested. It understands Python on a deeper level -than all other static analysis frameworks for Python. - -Jedi has support for two different goto functions. It's possible to search for -related names and to list all names in a Python file and infer them. Jedi -understands docstrings and you can use Jedi autocompletion in your REPL as -well. - -Jedi uses a very simple API to connect with IDE's. There's a reference -implementation as a `VIM-Plugin `_, -which uses Jedi's autocompletion. We encourage you to use Jedi in your IDEs. -It's really easy. - -Jedi can currently be used with the following editors/projects: - -- Vim (jedi-vim_, YouCompleteMe_, deoplete-jedi_, completor.vim_) -- Emacs (Jedi.el_, company-mode_, elpy_, anaconda-mode_, ycmd_) -- Sublime Text (SublimeJEDI_ [ST2 + ST3], anaconda_ [only ST3]) -- TextMate_ (Not sure if it's actually working) -- Kate_ version 4.13+ supports it natively, you have to enable it, though. [`proof - `_] -- Atom_ (autocomplete-python-jedi_) -- SourceLair_ -- `GNOME Builder`_ (with support for GObject Introspection) -- `Visual Studio Code`_ (via `Python Extension `_) -- Gedit (gedi_) -- wdb_ - Web Debugger -- `Eric IDE`_ (Available as a plugin) -- `Ipython 6.0.0+ `_ - -and many more! - - -Here are some pictures taken from jedi-vim_: - -.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_complete.png - -Completion for almost anything (Ctrl+Space). - -.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_function.png - -Display of function/class bodies, docstrings. - -.. image:: https://github.com/davidhalter/jedi/raw/master/docs/_screenshots/screenshot_pydoc.png - -Pydoc support (Shift+k). - -There is also support for goto and renaming. - -Get the latest version from `github `_ -(master branch should always be kind of stable/working). - -Docs are available at `https://jedi.readthedocs.org/en/latest/ -`_. Pull requests with documentation -enhancements and/or fixes are awesome and most welcome. Jedi uses `semantic -versioning `_. - - -Installation -============ - - pip install jedi - -Note: This just installs the Jedi library, not the editor plugins. For -information about how to make it work with your editor, refer to the -corresponding documentation. - -You don't want to use ``pip``? Please refer to the `manual -`_. - - -Feature Support and Caveats -=========================== - -Jedi really understands your Python code. For a comprehensive list what Jedi -understands, see: `Features -`_. A list of -caveats can be found on the same page. - -You can run Jedi on cPython 2.6, 2.7, 3.3, 3.4 or 3.5 but it should also -understand/parse code older than those versions. - -Tips on how to use Jedi efficiently can be found `here -`_. - -API ---- - -You can find the documentation for the `API here `_. - - -Autocompletion / Goto / Pydoc ------------------------------ - -Please check the API for a good explanation. There are the following commands: - -- ``jedi.Script.goto_assignments`` -- ``jedi.Script.completions`` -- ``jedi.Script.usages`` - -The returned objects are very powerful and really all you might need. - - -Autocompletion in your REPL (IPython, etc.) -------------------------------------------- - -Starting with Ipython `6.0.0` Jedi is a dependency of IPython. Autocompletion -in IPython is therefore possible without additional configuration. - -It's possible to have Jedi autocompletion in REPL modes - `example video `_. -This means that in Python you can enable tab completion in a `REPL -`_. - - -Static Analysis / Linter ------------------------- - -To do all forms of static analysis, please try to use ``jedi.names``. It will -return a list of names that you can use to infer types and so on. - -Linting is another thing that is going to be part of Jedi. For now you can try -an alpha version ``python -m jedi linter``. The API might change though and -it's still buggy. It's Jedi's goal to be smarter than classic linter and -understand ``AttributeError`` and other code issues. - - -Refactoring ------------ - -Jedi's parser would support refactoring, but there's no API to use it right -now. If you're interested in helping out here, let me know. With the latest -parser changes, it should be very easy to actually make it work. - - -Development -=========== - -There's a pretty good and extensive `development documentation -`_. - - -Testing -======= - -The test suite depends on ``tox`` and ``pytest``:: - - pip install tox pytest - -To run the tests for all supported Python versions:: - - tox - -If you want to test only a specific Python version (e.g. Python 2.7), it's as -easy as :: - - tox -e py27 - -Tests are also run automatically on `Travis CI -`_. - -For more detailed information visit the `testing documentation -`_ - - -Acknowledgements -================ - -- Takafumi Arakaki (@tkf) for creating a solid test environment and a lot of - other things. -- Danilo Bargen (@dbrgn) for general housekeeping and being a good friend :). -- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2 - (originally used in lib2to3). - - - -.. _jedi-vim: https://github.com/davidhalter/jedi-vim -.. _youcompleteme: http://valloric.github.io/YouCompleteMe/ -.. _deoplete-jedi: https://github.com/zchee/deoplete-jedi -.. _completor.vim: https://github.com/maralla/completor.vim -.. _Jedi.el: https://github.com/tkf/emacs-jedi -.. _company-mode: https://github.com/syohex/emacs-company-jedi -.. _elpy: https://github.com/jorgenschaefer/elpy -.. _anaconda-mode: https://github.com/proofit404/anaconda-mode -.. _ycmd: https://github.com/abingham/emacs-ycmd -.. _sublimejedi: https://github.com/srusskih/SublimeJEDI -.. _anaconda: https://github.com/DamnWidget/anaconda -.. _wdb: https://github.com/Kozea/wdb -.. _TextMate: https://github.com/lawrenceakka/python-jedi.tmbundle -.. _Kate: http://kate-editor.org -.. _Atom: https://atom.io/ -.. _autocomplete-python-jedi: https://atom.io/packages/autocomplete-python-jedi -.. _SourceLair: https://www.sourcelair.com -.. _GNOME Builder: https://wiki.gnome.org/Apps/Builder -.. _Visual Studio Code: https://code.visualstudio.com/ -.. _gedi: https://github.com/isamert/gedi -.. _Eric IDE: http://eric-ide.python-projects.org - - -.. :changelog: - -Changelog ---------- - -0.11.0 (2017-09-20) -+++++++++++++++++++ - -- Split Jedi's parser into a separate project called ``parso``. -- Avoiding side effects in REPL completion. -- Numpy docstring support should be much better. -- Moved the `settings.*recursion*` away, they are no longer usable. - -0.10.2 (2017-04-05) -+++++++++++++++++++ - -- Python Packaging sucks. Some files were not included in 0.10.1. - -0.10.1 (2017-04-05) -+++++++++++++++++++ - -- Fixed a few very annoying bugs. -- Prepared the parser to be factored out of Jedi. - -0.10.0 (2017-02-03) -+++++++++++++++++++ - -- Actual semantic completions for the complete Python syntax. -- Basic type inference for ``yield from`` PEP 380. -- PEP 484 support (most of the important features of it). Thanks Claude! (@reinhrst) -- Added ``get_line_code`` to ``Definition`` and ``Completion`` objects. -- Completely rewritten the type inference engine. -- A new and better parser for (fast) parsing diffs of Python code. - -0.9.0 (2015-04-10) -++++++++++++++++++ - -- The import logic has been rewritten to look more like Python's. There is now - an ``Evaluator.modules`` import cache, which resembles ``sys.modules``. -- Integrated the parser of 2to3. This will make refactoring possible. It will - also be possible to check for error messages (like compiling an AST would give) - in the future. -- With the new parser, the evaluation also completely changed. It's now simpler - and more readable. -- Completely rewritten REPL completion. -- Added ``jedi.names``, a command to do static analysis. Thanks to that - sourcegraph guys for sponsoring this! -- Alpha version of the linter. - - -0.8.1 (2014-07-23) -+++++++++++++++++++ - -- Bugfix release, the last release forgot to include files that improve - autocompletion for builtin libraries. Fixed. - -0.8.0 (2014-05-05) -+++++++++++++++++++ - -- Memory Consumption for compiled modules (e.g. builtins, sys) has been reduced - drastically. Loading times are down as well (it takes basically as long as an - import). -- REPL completion is starting to become usable. -- Various small API changes. Generally this release focuses on stability and - refactoring of internal APIs. -- Introducing operator precedence, which makes calculating correct Array - indices and ``__getattr__`` strings possible. - -0.7.0 (2013-08-09) -++++++++++++++++++ - -- Switched from LGPL to MIT license. -- Added an Interpreter class to the API to make autocompletion in REPL - possible. -- Added autocompletion support for namespace packages. -- Add sith.py, a new random testing method. - -0.6.0 (2013-05-14) -++++++++++++++++++ - -- Much faster parser with builtin part caching. -- A test suite, thanks @tkf. - -0.5 versions (2012) -+++++++++++++++++++ - -- Initial development. - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/RECORD b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/RECORD deleted file mode 100644 index 1b28107..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/RECORD +++ /dev/null @@ -1,211 +0,0 @@ -jedi/__init__.py,sha256=-U3en9SeER8H_YJiQC17l66xiSMEafK_BYY3ru8sXDI,1597 -jedi/__main__.py,sha256=jkG0jwBmWM95hFYQTbN2ZjknJYVJS1lsoO5T-X9vPjY,1427 -jedi/_compatibility.py,sha256=8BEjsDDoj-5Wcy2GMgvVvMd6HaK6yXO8rKYhzkZVV9w,9022 -jedi/cache.py,sha256=ZVJH-2JqIvhw1eNbxiiThrzz1R0YJgOPSf5qvmwp7CY,3600 -jedi/debug.py,sha256=a_LcGqasBm9qkugqKNPCVX3T8NLUKJDb-4I7aurqB_M,3417 -jedi/parser_utils.py,sha256=T7N4gMpMcf2K20z6aJQO2wzKLrTM5ML9ksrMxC1MyT0,7484 -jedi/refactoring.py,sha256=rg0jBMDCVUFT2CygmEMIeHTZxZ8hHlNkmCuOYB23luI,6851 -jedi/settings.py,sha256=KcM1E8Nn9bjHoonQ2FliQkxVaXpXfZWMxk50REx8O50,3768 -jedi/utils.py,sha256=K0rhUsRX2-O_E0f1O79Ei0SrHbxG27koJ115vy-rk00,4635 -jedi/api/__init__.py,sha256=ue86MsmeB5d3aK3A0kgsJCosKWoRlX4Cic5SZ92p9tQ,16616 -jedi/api/classes.py,sha256=AlJh087asHKYhU-lx8rJKmqp1F0veUMY0Ho-ctvN1iM,22979 -jedi/api/completion.py,sha256=tbIBMEpPGreHl1AT6NvidzIykhgNmbeLiCx1dL70M7o,11770 -jedi/api/helpers.py,sha256=OCZmVa1b_30FOHkfSoGTsGxegTlvuF8zBy3CfMnF6X0,10805 -jedi/api/interpreter.py,sha256=KrgEoqUgSF-gzsMKflcXO1_Rwsdh1N7Xh5HvwO3hLPk,1497 -jedi/api/keywords.py,sha256=UsJIdq9wsxvidUs5ignG4507fbj9AlaatEVnlRYqxn0,3707 -jedi/api/replstartup.py,sha256=jcUVaTQYlkBlec4-00HtWYO3iB3Yj5og3SI8INbeLQg,832 -jedi/common/__init__.py,sha256=4TYbU_MxgzG_T381EwR__cYT9XjI1pT9OsqRowu3324,60 -jedi/common/context.py,sha256=rHwPB4aBUUudyC0ZPWU5BvJGagkyOAMj_eqSKXZ-Ut8,1798 -jedi/evaluate/__init__.py,sha256=JhPe6XCkuJpB-_niPXp_HBXc9rsWYG2K1FmxUN-kGuY,16123 -jedi/evaluate/analysis.py,sha256=Zdq-Nx2mQaKLCWLG3mmdyYJhvXEzCoMg7xhq4TcbQqQ,7859 -jedi/evaluate/arguments.py,sha256=__9PMWarYJoovgcgN88vpUHzmyd3x4EBo5aFAkryggg,9654 -jedi/evaluate/base_context.py,sha256=31d1iErAQgAf0cJpJUhw_IHh-rjZRkx-0Cy2s2qUswc,8790 -jedi/evaluate/cache.py,sha256=kwqnGHtjUUFvaLaNU93Fnnb1AsgbLRYfwlJxjxaVgwU,2461 -jedi/evaluate/docstrings.py,sha256=6oageQJlgetRugtN1naQC98gApuSKc4RJBTwAMv_P04,10293 -jedi/evaluate/dynamic.py,sha256=jub0xZsA6sQY9AIKuvuqxb_3HQM8IoBSSRmQg7K8zeA,7536 -jedi/evaluate/filters.py,sha256=mevyNXl4dOjEhovDK1ZAuBb73l3NCoI-RvkNmDi9AiI,14315 -jedi/evaluate/finder.py,sha256=StETqO6YPIta4utpt_7sZX7PLL8R1RIKOutbhVKIV3M,10858 -jedi/evaluate/flow_analysis.py,sha256=EBG7mJkLDTGgM2O6AJby7PN8qQer61gDeGE9GehZFHw,4077 -jedi/evaluate/helpers.py,sha256=VjNdWiCOj_mpSLracWI22o3wwQcnUZkuBBiO1jD_KpU,6187 -jedi/evaluate/imports.py,sha256=Oj5IzhF920sO-MPNRCpki6sOYqh-EqutyV51yrJujYg,22282 -jedi/evaluate/jedi_typing.py,sha256=xuI1PFB-uhB9Y31z8ediR_9ayS0z4ljDRPOB5L8E7XQ,2563 -jedi/evaluate/lazy_context.py,sha256=D6VJh-fwtrxywBY9CvDu0XARxhuirj61BXvDTqDYY9Q,1735 -jedi/evaluate/param.py,sha256=Sx6K9brKPIzSHYMGWW8rIZhpj_5qh8YtMCxi2U5OsTE,7914 -jedi/evaluate/parser_cache.py,sha256=Hk2-SY9PWSeYR9KZw7lOReBnUcw7MDDlG1dPuXJnMJM,172 -jedi/evaluate/pep0484.py,sha256=FKKOevxT78b1EQNjQkoIsRl0EpFQl9oe0WcyiQSnAXM,8087 -jedi/evaluate/project.py,sha256=3O5VL1TN2rkIp3Yf-XksHRBT_MmD_Kaxfi4_eUQdIQI,1023 -jedi/evaluate/recursion.py,sha256=XPt-DBn4LXN5CJL8pk3AW1ZiuP1J6m5g6otKLjCWdEc,4225 -jedi/evaluate/site.py,sha256=ttpVSiA5LM6OJkDYGiWR3CLGahpGiEgpBfj9q30Dgyw,3592 -jedi/evaluate/stdlib.py,sha256=bdTLw_1hfjep9MB9O5KbaokgncfPuE56e2tUDMKP7b0,11359 -jedi/evaluate/syntax_tree.py,sha256=NdQwyNDP2-HkLmLLx_CTYL3DcS-aSUBaOUL878Wmnj0,22899 -jedi/evaluate/sys_path.py,sha256=dpPdqV3S0kF-g3rF3G7yqEL5ugBW-3wq-UlWMPVB6rY,10920 -jedi/evaluate/usages.py,sha256=tdBEkLqOdgdIYJ2nTN-lypznwmx2GVt7tsY_7xqMi6c,2382 -jedi/evaluate/utils.py,sha256=uALOgaW2k6WuqbwxfySKdtjqYTCKL9tBzCkr7DjRNEU,3371 -jedi/evaluate/compiled/__init__.py,sha256=ibI7WFWGSAz6pry_ZukxOR_fCehNBvYz8VjL3REz_tk,21605 -jedi/evaluate/compiled/fake.py,sha256=hI-GGx40wWPWKG4iQzX68xPzbjHP_wlXqwLXsmg2Yw4,6534 -jedi/evaluate/compiled/getattr_static.py,sha256=f8x0lF5yYZmQUXQyScyMz40AIqYOuJ0M7NviY595Jjg,5772 -jedi/evaluate/compiled/mixed.py,sha256=2-oJNit8Bb8p-ujUTzWrhJ3MPbM8GaOANGCgh6V6Npc,7955 -jedi/evaluate/compiled/fake/_functools.pym,sha256=VWfkjpbuYg72FRRLbgPYXUjIVEEhZn4hJORih0LA4Jc,325 -jedi/evaluate/compiled/fake/_sqlite3.pym,sha256=OyodpClVDEGXjHXXQNx9ckDdIG59u2CjKsLJu5mke-k,489 -jedi/evaluate/compiled/fake/_sre.pym,sha256=s3NJJ-35qKSGB-fdw3-EU70U4dZTFoXAPFSEb9i0ZZU,3019 -jedi/evaluate/compiled/fake/_weakref.pym,sha256=7oqmsoOIy5SixiD54ZeMDdRvIMus77yHZRoCDj1xxrs,198 -jedi/evaluate/compiled/fake/builtins.pym,sha256=pYIdcuBRcV-VsXjn_Igywkg81Gt0cdcU7VFcMayKAVU,5560 -jedi/evaluate/compiled/fake/datetime.pym,sha256=xxIqy49l4mePOnaoGfjiKaN5w9JvPb9rVUWJgpMdVsY,77 -jedi/evaluate/compiled/fake/io.pym,sha256=aUD-B-SXs6sP-msDf8GzXvCMjx4llMlnZ8TxhxEBoR4,205 -jedi/evaluate/compiled/fake/operator.pym,sha256=nbMI33j8TF1ecQIu6j_xhB8j6Kp4e_LLaM9l-5iXmx8,1015 -jedi/evaluate/compiled/fake/posix.pym,sha256=KuVdP7_TMjd7coui58ak6y2SoStaoUpMZkCElXz8fCc,58 -jedi/evaluate/context/__init__.py,sha256=3IbVtWice8nnEyeLivr0WuzE7nBZSN3ntlkbbeynOa8,330 -jedi/evaluate/context/function.py,sha256=JbaJbfZR2BAbw8dC68mC3jU9IVdZ_FzDJKn-gWuFTYc,9184 -jedi/evaluate/context/instance.py,sha256=4nf5NolGZeKIsB0YImaC2qOg6pH8b0n2oMibsWEBVs8,16668 -jedi/evaluate/context/iterable.py,sha256=ny6BTCP13GryucXwFEvrvLZt-oK33ftdOmuhUmUenH0,24482 -jedi/evaluate/context/klass.py,sha256=qUfHrzqqNiVdtB8eikZj-5tn4vqzAApY1MLSWGvVeL4,8100 -jedi/evaluate/context/module.py,sha256=Hdh7iQo5L4ZRsG62Uo2IuUMeoGfcPGpdqidcTsOEOpw,7657 -jedi/evaluate/context/namespace.py,sha256=ovjId5ZvjscVcwG15IhbSrYn3ehbXRWeaSu0gXA5h4w,2214 -jedi-0.11.1.dist-info/DESCRIPTION.rst,sha256=1KSOf5PS7l0ioGAb6Kmd3aaTVJiCq6vXS3xI4ARv4X4,10569 -jedi-0.11.1.dist-info/METADATA,sha256=DLjIvvVQ-Pll9bdISSAMxGOeRx7v-oD2URsSFMInfNc,11812 -jedi-0.11.1.dist-info/RECORD,, -jedi-0.11.1.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110 -jedi-0.11.1.dist-info/metadata.json,sha256=VozZDZ_c7rgwSFleBaqLJgw__cVEzUQGd_CFEpcQvtM,1357 -jedi-0.11.1.dist-info/top_level.txt,sha256=s2r0f2Qa0jN2Cc9RwvYlU_2RQSHDHtbvDlqy6w8PfP8,10 -test/completion/__init__.py,sha256=EXR1qczisa4P9Kyau8wdh85TRFM0f9HTMLpEZXxhbuw,77 -test/completion/arrays.py,sha256=5HceQJyxPcBxuecCF-_QRKlEr57nFbenSYMWKreqeF0,5199 -test/completion/async_.py,sha256=Z7Jdq3I5jm3Tqnj6b-tW_knlAPEJgObUefUZJcUxr20,506 -test/completion/basic.py,sha256=JdnyXPNYFl9pHbQk3Q7P9Ltf1wSUY3mTrZgW44R0fRE,3896 -test/completion/classes.py,sha256=NAP4815sO5Yfl9L7hza9hfhIqk0n5__0cxk_FyRi11c,8297 -test/completion/completion.py,sha256=CPb-OFawEKOF5rQfj_iiWLFLdyCp3hv3yLFYw33p4NQ,565 -test/completion/complex.py,sha256=8U52qye1FR3rMDPpYWAYKj3WrC4DrCLat_6LOK7YmFw,197 -test/completion/comprehensions.py,sha256=Bdr9MyQtpg8VnKLDc2IKnLLxTcjlS0UIfT-Rt8helv0,3083 -test/completion/context.py,sha256=Eqa2TEZWQ5FuY29JQWx-o54HGUNtQsXs4ZINAYQPYq4,520 -test/completion/decorators.py,sha256=wp6C9v9rRYG0t1GOWTt1s776zv9Xs411m-Dn4zkC_gc,5198 -test/completion/definition.py,sha256=bgg-_bc5Lx65Ei-RiSWnOgIZh0C8xEk0-9L9T-29ICc,1072 -test/completion/descriptors.py,sha256=oM8453A0-oD45ufZhK8xEFIhVLjG_FVnxbIgfw-niOo,3421 -test/completion/docstring.py,sha256=NPW95qIGhItT2fzDzGYLB0BCKvtcAhi1HY9gpXAQqJE,3595 -test/completion/dynamic_arrays.py,sha256=Xni-30peE6rC5Tpm3o1noEqHIYZ5FyDcAEYQmDf38Rs,4263 -test/completion/dynamic_params.py,sha256=M5nEIjoeGc-PFJUvO5TV57qARcG-GykwKlyT4TqxZa0,1921 -test/completion/flow_analysis.py,sha256=FW-85o2ZNND5D7iRmBliNX8fjfa1mlKxiTn7v_CH77Y,4028 -test/completion/functions.py,sha256=Up4tFaPl41BG29izLtCZ6Lq9C0b9ivNqL1MjYkVg5rE,6731 -test/completion/generators.py,sha256=K9xb-jRX7B1fck4290aeL9m-4ob1XVnLIF1EBxaBWRY,2897 -test/completion/goto.py,sha256=26eh4LnUn0D5X3YGplDS6wDM_ZBERsKqApGvy0GQK74,3011 -test/completion/imports.py,sha256=_vrma0z8V2I8tRZVKt5pZYfj5W5YfUz2paXmfU9TUQY,4992 -test/completion/invalid.py,sha256=S2IS6MKmS1_GpO-2FqMnMDKvznbW1BY_VUmJlvBmvng,2709 -test/completion/isinstance.py,sha256=TCLiLsO0G1TT_NuxIQ2sJ-nupnUIDFc5Of-XyXUJ5b0,1747 -test/completion/keywords.py,sha256=IZqHB2rnlIk9WHGEpfgaQFIV-vJQeus7IJgEew3nSmM,577 -test/completion/lambdas.py,sha256=Ex7mZ_HfDTn61WtFlvAWewZ0A7UsXC48jfnAraCBjn4,1833 -test/completion/named_param.py,sha256=WKCtNJrmbdW7-tcs66qEDF497srVAE_ykB2U0PIxbXI,782 -test/completion/on_import.py,sha256=kR5pmY9WEI7jEAsu-AMeFj5ZeBBom4tyWmnqlOyu-rQ,2061 -test/completion/ordering.py,sha256=9MtjcukeU4RD8LovOF484YMtX29M0YW-rV58th-rDE8,2080 -test/completion/parser.py,sha256=ULhwabJL3r6njgZY-v_y7qqQqnBpqRvL4hweOQrrUXg,744 -test/completion/pep0484_basic.py,sha256=es0pK0laucw1N3wsRICDIvCfxv8Ajx2RGGnmTam2Pgs,2687 -test/completion/pep0484_comments.py,sha256=mmsoddQZ4dAYxRoSR4EJIVQIdKHz37KkAOEucO4LBSs,1669 -test/completion/pep0484_typing.py,sha256=aDwA-TdyR7yckeAgCxxXG6Bzj_7mTQv1gSZ9o4u_9HM,4971 -test/completion/pep0526_variables.py,sha256=essPDFbei6YtbocYkTMveAK1ChexSty5RjdaZRoKz64,386 -test/completion/precedence.py,sha256=s4ATwcLOtws5iPcehOSkl0m4N47OPd0rwm8YC8-mPsE,1910 -test/completion/recursion.py,sha256=X4-5-d4TyLZP3HxqNO0DTeqZLkV5fgF_o-NLtV4rIOk,1237 -test/completion/stdlib.py,sha256=Cy0w3AQc-1OKjKRHLke95zoBoUD_wqQF_9dpy8fFr-c,3451 -test/completion/sys_path.py,sha256=5rSjtJn_uK5kwJ4cLlSWmTbX9ny80khiy7bAatm28KE,458 -test/completion/types.py,sha256=mDpkevuiKQwHVZsZ2oNSOS0PJrve_40c5iKrlxBdMPU,1384 -test/completion/usages.py,sha256=g0ppNKlCd07UXRpcnCNOQEtNSWOtZru7ATLt102ZcqI,5902 -test/completion/import_tree/__init__.py,sha256=49MZ69jP853w34OQeY01zLo4Skqiv7hYbFPn_uLlqOQ,80 -test/completion/import_tree/classes.py,sha256=akStUyuAOcpSuvhM5Kz3JV-048XBZgmRKRFhkKo7vf0,131 -test/completion/import_tree/flow_import.py,sha256=zPzgs5xFTGTKPyGb3H3Gw7GMer99JDD_u660yKJ8bJA,39 -test/completion/import_tree/invisible_pkg.py,sha256=hWRh8t7Cans_gHDaB6B7KMz7EY2bwx3Eq12tSkD6ORU,193 -test/completion/import_tree/mod1.py,sha256=JG1ymTjFzfS3wNtZuX4GRhg-BNPcGBj_O_8fTH0Etnk,61 -test/completion/import_tree/mod2.py,sha256=TLDy6i1SnFdtGy2WHgSJUqnDaeHQSuGOkqSKWG4kBmk,27 -test/completion/import_tree/random.py,sha256=iviTEgrCXtZ6WC5ikvJgEVk7gtpfUjrOG9Z3CtmhGUE,74 -test/completion/import_tree/recurse_class1.py,sha256=GN4ZGNnvjZryTcYmCtvDN9qbUYJtUPipU_9lmbZPgG8,80 -test/completion/import_tree/recurse_class2.py,sha256=VImpnbzOgZWTux1o9-MdsGYEUcgW3HFyUF80cifpLNA,59 -test/completion/import_tree/rename1.py,sha256=bWsE77xszb9cL5HV3KlPx8bfhvSp6mlQ-5sqQD1YvfY,41 -test/completion/import_tree/rename2.py,sha256=V6sOSY1dM0oW4KMS9Mj198zhNORsW0tVy-sRJ55RHGA,63 -test/completion/import_tree/pkg/__init__.py,sha256=hW0lIwwtBSeggq26M4-a_HDbbLK0XD1ez1nCCCuwoZc,29 -test/completion/import_tree/pkg/mod1.py,sha256=nAt8anFLeRosBw020LhIsQvAkVrrSi-QKUIgsMaBAGI,37 -test/completion/thirdparty/PyQt4_.py,sha256=zy1SrigbvQ8gsEcIRcZ-1VNTISagP-X5JHaQ8bPC2kQ,320 -test/completion/thirdparty/django_.py,sha256=ZVaLc-Dnn7cJ9F3NTHEr-RyGCZjxv_TA9A6PeIgXlEE,212 -test/completion/thirdparty/jedi_.py,sha256=DWfz5itKd1_9oINrPW-ig7zndAx5ECXTKuyW4zaf4nM,1474 -test/completion/thirdparty/psycopg2_.py,sha256=ENr0FP9o7uzRl_zPAxKyXDkS78NTgBP8ZhAKEMEmXSE,134 -test/completion/thirdparty/pylab_.py,sha256=lSkp9kLX72WxVexRfgWk3Qj1uZoQaxz5yArrGBWK6x8,544 -test/test_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_api/test_analysis.py,sha256=4Lp7oPequSjD9w83lduNENHQ0wmyuyRxh9gH2RNTEUo,346 -test/test_api/test_api.py,sha256=IhYO5Cm1LROoScU_EKhJjNjs19SVffe29mlqHsx4flQ,6911 -test/test_api/test_api_classes_follow_definition.py,sha256=ri8sAFnY9IvLtLexcB0W1FtVVetrbYKaNAKETiED8vE,2032 -test/test_api/test_call_signatures.py,sha256=BpG5PzoMjrzoeyT5hIQsOCl-V5JZSfh2cAnsGbzv_uE,12549 -test/test_api/test_classes.py,sha256=Mx9dSZQB6H7IDwMSZvDrNoN_DYH3QUI38US7uI1rmQU,11881 -test/test_api/test_completion.py,sha256=EbEIBSSjZgdG0D58I_c0YLL_XCSLxDGNO_Ldl8j6JwA,1146 -test/test_api/test_defined_names.py,sha256=B8RNywr0jOCLI64aTVzD15qlj2oFiLpAHNcWLg0RxaU,2620 -test/test_api/test_full_name.py,sha256=61hrtBZRAH9oWCOeA7OEJ5hviuqw_1wKqVxhK_Q72ms,2884 -test/test_api/test_interpreter.py,sha256=IyJKRtXA95hFckH5iacBqMSFMj0nO1uGgodzD5jdvcY,8494 -test/test_api/test_unicode.py,sha256=mb-kjTbjlN8ws4uGYjv91vTlNUNW1V8FWrb2VhP409w,2147 -test/test_api/test_usages.py,sha256=lwYjYXGLI_R9UWkWwBZwRLfrCuMC-VKoJk228GES_kY,170 -test/test_api/import_tree_for_usages/__init__.py,sha256=EXjwZANe9285HuLjQfBXrK-yK0JhqGYoKV1NTf4030M,45 -test/test_api/import_tree_for_usages/a.py,sha256=aETdshVHQMtJ8QWklAJ3UKP8X8QplxuW8OuCVWfNBwU,40 -test/test_api/import_tree_for_usages/b.py,sha256=B2qqFpBqHuyC1td2B_2qHm42nvYwXkLEGWqL6le7DWE,20 -test/test_api/simple_import/__init__.py,sha256=3yu_GEWkV_JRf99zvNqHs6b4kl3SXYwOJlimv2VYFXs,92 -test/test_api/simple_import/module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_api/simple_import/module2.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/test_absolute_import.py,sha256=PjI67Xr5fobgNNliJ8ZIaLjeHwDaqrC7qek0g5W0hgA,297 -test/test_evaluate/test_annotations.py,sha256=O0wUE5WKrgTSENZ9tlma-YoRPOGxBTua--fn_RCoEro,1459 -test/test_evaluate/test_buildout_detection.py,sha256=utUI_yg-x9w-K-mZds2IpdXv6v3wCkHQgMpDyp73AwY,2449 -test/test_evaluate/test_compiled.py,sha256=hdsAsQ4Lj2IrOmXYtJxXwaPMpeC-BW6ooStAfoCvIk4,2645 -test/test_evaluate/test_context.py,sha256=2ENeEXha85N8SHPq-rheSLShHkDXXMkAvhRyiPsKcZ4,263 -test/test_evaluate/test_docstring.py,sha256=SbiptZlr0sqM8ml3MhGlpIXdZSqsUI9Wj9JS9FNAxvQ,8889 -test/test_evaluate/test_extension.py,sha256=1rz5lO-5iE5slecvdrpAGeQkxZyoRLsSAuGvifilX3s,1680 -test/test_evaluate/test_helpers.py,sha256=BOKx5aAEAauAf7OrkbHHmbLhIsOrQbB3KVl1qdP2veI,334 -test/test_evaluate/test_implicit_namespace_package.py,sha256=Xn5GW6cBmHuyKbuuCe0j_z2mrtkQDLZAR1XVzaaJueA,2021 -test/test_evaluate/test_imports.py,sha256=Bxza2oPoRDEdIwrvdCHPEqBKgOt9fo6VMqhAp357Lew,8496 -test/test_evaluate/test_literals.py,sha256=l9046hj16OEpCGt6CxnJvANNAfMnBMrubr7tjCBL0xs,1160 -test/test_evaluate/test_mixed.py,sha256=vid8mp53Jo_BC8tI1UsSsReo6aiyYduwtacDqZJSFE4,160 -test/test_evaluate/test_namespace_package.py,sha256=QlefcR2AlDQnqETk_aXAvjyhcI61DwrBywrD4a8ZWa8,2463 -test/test_evaluate/test_precedence.py,sha256=vPCqH6thm1jRrd4fKYNv1nqIQ3mauAf4hu2F5BL2E1s,477 -test/test_evaluate/test_pyc.py,sha256=TZ_ghfj62BHXvKXSbNHn3QyUggM0OE47Sd8YWFMcBrw,1684 -test/test_evaluate/test_representation.py,sha256=1vURx387mz8I7WDzLB9jCQyqHxDhJRue4v4lO9Hx_bc,976 -test/test_evaluate/test_stdlib.py,sha256=4ET-3ggk9R3Y8kzHCilsrD8YoHi46KFYTKdZ5MAr6JM,2230 -test/test_evaluate/test_sys_path.py,sha256=m-3KJBQQ57y6rM1jA9x8Iod0Ba-qKRjh-Z0jbkHcYJg,2067 -test/test_evaluate/absolute_import/local_module.py,sha256=2_gsJH9Wg4ZMSvqrimaELsA6WAgBSm9al0FGgRguVgM,383 -test/test_evaluate/absolute_import/unittest.py,sha256=bTW1ZCQ0ViTk3f9Pz5iIIb0ukAXQ2AJ1D4UAS_XRVKI,437 -test/test_evaluate/buildout_project/buildout.cfg,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/buildout_project/bin/app,sha256=8G2uyRJW_zo6p25r8DzoYNdfsnQpzJr1FJUW3vLERHA,227 -test/test_evaluate/buildout_project/bin/binary_file,sha256=EsWTxb0vCXIYjrMOMr7nrUBgvlgsLGgmyv-JNyyoRwc,5 -test/test_evaluate/buildout_project/bin/empty_file,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/buildout_project/src/proj_name/module_name.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/flask-site-packages/flask_foo.py,sha256=tLkl02dDn-zWuXBiI5yz0s_oYM56AnYL_Kt3XdHWsMo,28 -test/test_evaluate/flask-site-packages/flask/__init__.py,sha256=9rREU_D-MjXn6hKj3nurKmv5AzOVtVeT_0Mtuahhgss,21 -test/test_evaluate/flask-site-packages/flask/ext/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 -test/test_evaluate/flask-site-packages/flask_baz/__init__.py,sha256=EWYM55mzbPcswv2Ttvd2GEcAuBsqm13piIHo0ec3ZtQ,8 -test/test_evaluate/flask-site-packages/flaskext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/flask-site-packages/flaskext/bar.py,sha256=UiL7th9-n2OyBUYCGqxdWmVzmoEOu1mPqGj9UDJKtIM,28 -test/test_evaluate/flask-site-packages/flaskext/moo/__init__.py,sha256=EHUfjRJdPtNv_CfWCrh71y6LWCGaL8Cd4BtXvh-3X-I,8 -test/test_evaluate/implicit_namespace_package/ns1/pkg/ns1_file.py,sha256=ic5O9gqRCw1SIkCGvZHLa3phGEcxYtHQEcBLCpv3Tno,18 -test/test_evaluate/implicit_namespace_package/ns2/pkg/ns2_file.py,sha256=Hw9-IVWkpTZPWPVCXy2Md6EVdoDDi7tG9igzaWtp7C0,18 -test/test_evaluate/implicit_nested_namespaces/namespace/pkg/module.py,sha256=9H0YG2bDCiSNSPRvTVWXA1sQ6TIa9UhOHV3s16KJS_U,10 -test/test_evaluate/init_extension_module/__init__.cpython-34m.so,sha256=JV7_ByZ0zpaQg_VugEzBE28Xudgkv1wnEzhSTMVMhUg,16493 -test/test_evaluate/init_extension_module/module.c,sha256=j8_84ScWZ_Q3XZLzxSk4wsRxkVaROxS45AuaN_0HSKE,294 -test/test_evaluate/init_extension_module/setup.py,sha256=-U3oUIAwCdV4FXvZtQeDukam5cMrijTdqDMPhYuCLo0,250 -test/test_evaluate/namespace_package/ns1/pkg/__init__.py,sha256=Dknzk1_-KvJz7vI3n_iUrR6OKHPjFsrYgyPAmxlKPtk,214 -test/test_evaluate/namespace_package/ns1/pkg/ns1_file.py,sha256=ic5O9gqRCw1SIkCGvZHLa3phGEcxYtHQEcBLCpv3Tno,18 -test/test_evaluate/namespace_package/ns1/pkg/ns1_folder/__init__.py,sha256=Wmyh2Y6Tg6CwcumhjL-bAtjJj4AGOT6hAzUAkPZVckM,20 -test/test_evaluate/namespace_package/ns2/pkg/ns2_file.py,sha256=Hw9-IVWkpTZPWPVCXy2Md6EVdoDDi7tG9igzaWtp7C0,18 -test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/__init__.py,sha256=n6WLWeSNngmBdu0sORWUGngBL8QCfh9_2OyI_5jV4F0,20 -test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/nested/__init__.py,sha256=ULi_Ogi046zAybqNEOtCkalNk9hH96OJHGVx_cNKk4M,16 -test/test_evaluate/nested_namespaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/nested_namespaces/namespace/__init__.py,sha256=VIMfZQbMYGhKbjuveuawOViJlI8V0kqFnhAKeRHGND0,94 -test/test_evaluate/nested_namespaces/namespace/pkg/__init__.py,sha256=9H0YG2bDCiSNSPRvTVWXA1sQ6TIa9UhOHV3s16KJS_U,10 -test/test_evaluate/not_in_sys_path/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/not_in_sys_path/not_in_sys_path.py,sha256=XGMk2Dok7Umoa6apR7CuZL1JXIbTnAkOHF8YUqfjWHQ,10 -test/test_evaluate/not_in_sys_path/not_in_sys_path_package/__init__.py,sha256=IJNMA3M0TsDJO8ye4SjT0OF_RVpanvZQiZDKbHFRkrE,18 -test/test_evaluate/not_in_sys_path/not_in_sys_path_package/module.py,sha256=aH28SKSSizrNYf0cZ22DSG2QiiSS-ttbg3qVf1uu9Kg,25 -test/test_evaluate/not_in_sys_path/pkg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -test/test_evaluate/not_in_sys_path/pkg/module.py,sha256=IiPK-LSuI_6C-q5OGgRBUrsZUQ9-ruM_LIs30EDZmLg,221 -test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/egg_link.egg-link,sha256=woLYJdpfyLtCQRIt5ZecMPOEDXwrOANz-akSxLpmfGA,20 -test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/foo.pth,sha256=fRnMC9UXbnDNXdpThDpVs2C9vVKcPtRchSD-W9V3FS8,19 -test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/import_smth.pth,sha256=51z-kZosf8-sS4zASDOCa4-E3dShdyGOmFpwQyY5t2c,31 -test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/relative.egg-link,sha256=P-bTO1QzKV9IbhQaTWuXHM5LDJjG7CDzKxzpHgo-MsU,25 -test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/smth.py,sha256=zKJEAd1K6gfuQqfKpy6MER0yiNIAYcBLJVsHLqDMJP0,124 -test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/dir-from-foo-pth/__init__.py,sha256=EvQn8oTRl1t9p_CTb5JDXzL2q0r_GPjfiAqlMWFNb64,106 -test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/egg_link.egg-link,sha256=woLYJdpfyLtCQRIt5ZecMPOEDXwrOANz-akSxLpmfGA,20 -test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/foo.pth,sha256=fRnMC9UXbnDNXdpThDpVs2C9vVKcPtRchSD-W9V3FS8,19 -test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/import_smth.pth,sha256=51z-kZosf8-sS4zASDOCa4-E3dShdyGOmFpwQyY5t2c,31 -test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/relative.egg-link,sha256=P-bTO1QzKV9IbhQaTWuXHM5LDJjG7CDzKxzpHgo-MsU,25 -test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/smth.py,sha256=zKJEAd1K6gfuQqfKpy6MER0yiNIAYcBLJVsHLqDMJP0,124 -test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/dir-from-foo-pth/__init__.py,sha256=EvQn8oTRl1t9p_CTb5JDXzL2q0r_GPjfiAqlMWFNb64,106 -test/test_evaluate/zipped_imports/not_pkg.zip,sha256=uASDmvuVMewop1KR-kWKM0awm9nu5W5pnXpI7il45VA,204 -test/test_evaluate/zipped_imports/pkg.zip,sha256=3tGybC1JlI_OYzluICd6bKeYsrDJ-QF42gscoVvmNwQ,504 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/WHEEL b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/WHEEL deleted file mode 100644 index 8b6dd1b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/WHEEL +++ /dev/null @@ -1,6 +0,0 @@ -Wheel-Version: 1.0 -Generator: bdist_wheel (0.29.0) -Root-Is-Purelib: true -Tag: py2-none-any -Tag: py3-none-any - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/metadata.json b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/metadata.json deleted file mode 100644 index 8596d97..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"classifiers": ["Development Status :: 4 - Beta", "Environment :: Plugins", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Text Editors :: Integrated Development Environments (IDE)", "Topic :: Utilities"], "extensions": {"python.details": {"contacts": [{"email": "davidhalter88@gmail.com", "name": "David Halter", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/davidhalter/jedi"}}}, "extras": ["dev"], "generator": "bdist_wheel (0.29.0)", "keywords": ["python", "completion", "refactoring", "vim"], "license": "MIT", "metadata_version": "2.0", "name": "jedi", "platform": "any", "run_requires": [{"extra": "dev", "requires": ["docopt"]}, {"requires": ["parso (==0.1.1)"]}], "summary": "An autocompletion tool for Python that can be used for text editors.", "version": "0.11.1"} \ No newline at end of file diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/requires.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/requires.txt deleted file mode 100644 index cba7acb..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/requires.txt +++ /dev/null @@ -1,4 +0,0 @@ -parso==0.1.1 - -[dev] -docopt diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/top_level.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/top_level.txt deleted file mode 100644 index e9c9ca9..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/EGG-INFO/top_level.txt +++ /dev/null @@ -1,2 +0,0 @@ -jedi -test diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/__init__.py deleted file mode 100644 index 1a1080a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/__init__.py +++ /dev/null @@ -1,43 +0,0 @@ -""" -Jedi is a static analysis tool for Python that can be used in IDEs/editors. Its -historic focus is autocompletion, but does static analysis for now as well. -Jedi is fast and is very well tested. It understands Python on a deeper level -than all other static analysis frameworks for Python. - -Jedi has support for two different goto functions. It's possible to search for -related names and to list all names in a Python file and infer them. Jedi -understands docstrings and you can use Jedi autocompletion in your REPL as -well. - -Jedi uses a very simple API to connect with IDE's. There's a reference -implementation as a `VIM-Plugin `_, -which uses Jedi's autocompletion. We encourage you to use Jedi in your IDEs. -It's really easy. - -To give you a simple example how you can use the Jedi library, here is an -example for the autocompletion feature: - ->>> import jedi ->>> source = ''' -... import datetime -... datetime.da''' ->>> script = jedi.Script(source, 3, len('datetime.da'), 'example.py') ->>> script - ->>> completions = script.completions() ->>> completions #doctest: +ELLIPSIS -[, , ...] ->>> print(completions[0].complete) -te ->>> print(completions[0].name) -date - -As you see Jedi is pretty simple and allows you to concentrate on writing a -good text editor, while still having very good IDE features for Python. -""" - -__version__ = '0.11.1' - -from jedi.api import Script, Interpreter, set_debug_function, \ - preload_module, names -from jedi import settings diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/__main__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/__main__.py deleted file mode 100644 index f2ee047..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/__main__.py +++ /dev/null @@ -1,48 +0,0 @@ -import sys -from os.path import join, dirname, abspath, isdir - - -def _start_linter(): - """ - This is a pre-alpha API. You're not supposed to use it at all, except for - testing. It will very likely change. - """ - import jedi - - if '--debug' in sys.argv: - jedi.set_debug_function() - - for path in sys.argv[2:]: - if path.startswith('--'): - continue - if isdir(path): - import fnmatch - import os - - paths = [] - for root, dirnames, filenames in os.walk(path): - for filename in fnmatch.filter(filenames, '*.py'): - paths.append(os.path.join(root, filename)) - else: - paths = [path] - - try: - for path in paths: - for error in jedi.Script(path=path)._analysis(): - print(error) - except Exception: - if '--pdb' in sys.argv: - import traceback - traceback.print_exc() - import pdb - pdb.post_mortem() - else: - raise - - -if len(sys.argv) == 2 and sys.argv[1] == 'repl': - # don't want to use __main__ only for repl yet, maybe we want to use it for - # something else. So just use the keyword ``repl`` for now. - print(join(dirname(abspath(__file__)), 'api', 'replstartup.py')) -elif len(sys.argv) > 1 and sys.argv[1] == 'linter': - _start_linter() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/_compatibility.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/_compatibility.py deleted file mode 100644 index 52a20fe..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/_compatibility.py +++ /dev/null @@ -1,291 +0,0 @@ -""" -To ensure compatibility from Python ``2.6`` - ``3.3``, a module has been -created. Clearly there is huge need to use conforming syntax. -""" -import sys -import imp -import os -import re -import pkgutil -import warnings -try: - import importlib -except ImportError: - pass - -# Cannot use sys.version.major and minor names, because in Python 2.6 it's not -# a namedtuple. -is_py3 = sys.version_info[0] >= 3 -is_py33 = is_py3 and sys.version_info[1] >= 3 -is_py34 = is_py3 and sys.version_info[1] >= 4 -is_py35 = is_py3 and sys.version_info[1] >= 5 -is_py26 = not is_py3 and sys.version_info[1] < 7 -py_version = int(str(sys.version_info[0]) + str(sys.version_info[1])) - - -class DummyFile(object): - def __init__(self, loader, string): - self.loader = loader - self.string = string - - def read(self): - return self.loader.get_source(self.string) - - def close(self): - del self.loader - - -def find_module_py34(string, path=None, fullname=None): - implicit_namespace_pkg = False - spec = None - loader = None - - spec = importlib.machinery.PathFinder.find_spec(string, path) - if hasattr(spec, 'origin'): - origin = spec.origin - implicit_namespace_pkg = origin == 'namespace' - - # We try to disambiguate implicit namespace pkgs with non implicit namespace pkgs - if implicit_namespace_pkg: - fullname = string if not path else fullname - implicit_ns_info = ImplicitNSInfo(fullname, spec.submodule_search_locations._path) - return None, implicit_ns_info, False - - # we have found the tail end of the dotted path - if hasattr(spec, 'loader'): - loader = spec.loader - return find_module_py33(string, path, loader) - -def find_module_py33(string, path=None, loader=None, fullname=None): - loader = loader or importlib.machinery.PathFinder.find_module(string, path) - - if loader is None and path is None: # Fallback to find builtins - try: - with warnings.catch_warnings(record=True): - # Mute "DeprecationWarning: Use importlib.util.find_spec() - # instead." While we should replace that in the future, it's - # probably good to wait until we deprecate Python 3.3, since - # it was added in Python 3.4 and find_loader hasn't been - # removed in 3.6. - loader = importlib.find_loader(string) - except ValueError as e: - # See #491. Importlib might raise a ValueError, to avoid this, we - # just raise an ImportError to fix the issue. - raise ImportError("Originally " + repr(e)) - - if loader is None: - raise ImportError("Couldn't find a loader for {0}".format(string)) - - try: - is_package = loader.is_package(string) - if is_package: - if hasattr(loader, 'path'): - module_path = os.path.dirname(loader.path) - else: - # At least zipimporter does not have path attribute - module_path = os.path.dirname(loader.get_filename(string)) - if hasattr(loader, 'archive'): - module_file = DummyFile(loader, string) - else: - module_file = None - else: - module_path = loader.get_filename(string) - module_file = DummyFile(loader, string) - except AttributeError: - # ExtensionLoader has not attribute get_filename, instead it has a - # path attribute that we can use to retrieve the module path - try: - module_path = loader.path - module_file = DummyFile(loader, string) - except AttributeError: - module_path = string - module_file = None - finally: - is_package = False - - if hasattr(loader, 'archive'): - module_path = loader.archive - - return module_file, module_path, is_package - - -def find_module_pre_py33(string, path=None, fullname=None): - try: - module_file, module_path, description = imp.find_module(string, path) - module_type = description[2] - return module_file, module_path, module_type is imp.PKG_DIRECTORY - except ImportError: - pass - - if path is None: - path = sys.path - for item in path: - loader = pkgutil.get_importer(item) - if loader: - try: - loader = loader.find_module(string) - if loader: - is_package = loader.is_package(string) - is_archive = hasattr(loader, 'archive') - try: - module_path = loader.get_filename(string) - except AttributeError: - # fallback for py26 - try: - module_path = loader._get_filename(string) - except AttributeError: - continue - if is_package: - module_path = os.path.dirname(module_path) - if is_archive: - module_path = loader.archive - file = None - if not is_package or is_archive: - file = DummyFile(loader, string) - return (file, module_path, is_package) - except ImportError: - pass - raise ImportError("No module named {0}".format(string)) - - -find_module = find_module_py33 if is_py33 else find_module_pre_py33 -find_module = find_module_py34 if is_py34 else find_module -find_module.__doc__ = """ -Provides information about a module. - -This function isolates the differences in importing libraries introduced with -python 3.3 on; it gets a module name and optionally a path. It will return a -tuple containin an open file for the module (if not builtin), the filename -or the name of the module if it is a builtin one and a boolean indicating -if the module is contained in a package. -""" - - -class ImplicitNSInfo(object): - """Stores information returned from an implicit namespace spec""" - def __init__(self, name, paths): - self.name = name - self.paths = paths - -# unicode function -try: - unicode = unicode -except NameError: - unicode = str - - -# re-raise function -if is_py3: - def reraise(exception, traceback): - raise exception.with_traceback(traceback) -else: - eval(compile(""" -def reraise(exception, traceback): - raise exception, None, traceback -""", 'blub', 'exec')) - -reraise.__doc__ = """ -Re-raise `exception` with a `traceback` object. - -Usage:: - - reraise(Exception, sys.exc_info()[2]) - -""" - -class Python3Method(object): - def __init__(self, func): - self.func = func - - def __get__(self, obj, objtype): - if obj is None: - return lambda *args, **kwargs: self.func(*args, **kwargs) - else: - return lambda *args, **kwargs: self.func(obj, *args, **kwargs) - - -def use_metaclass(meta, *bases): - """ Create a class with a metaclass. """ - if not bases: - bases = (object,) - return meta("HackClass", bases, {}) - - -try: - encoding = sys.stdout.encoding - if encoding is None: - encoding = 'utf-8' -except AttributeError: - encoding = 'ascii' - - -def u(string): - """Cast to unicode DAMMIT! - Written because Python2 repr always implicitly casts to a string, so we - have to cast back to a unicode (and we now that we always deal with valid - unicode, because we check that in the beginning). - """ - if is_py3: - return str(string) - - if not isinstance(string, unicode): - return unicode(str(string), 'UTF-8') - return string - -try: - import builtins # module name in python 3 -except ImportError: - import __builtin__ as builtins - - -import ast - - -def literal_eval(string): - # py3.0, py3.1 and py32 don't support unicode literals. Support those, I - # don't want to write two versions of the tokenizer. - if is_py3 and sys.version_info.minor < 3: - if re.match('[uU][\'"]', string): - string = string[1:] - return ast.literal_eval(string) - - -try: - from itertools import zip_longest -except ImportError: - from itertools import izip_longest as zip_longest # Python 2 - -try: - FileNotFoundError = FileNotFoundError -except NameError: - FileNotFoundError = IOError - - -def no_unicode_pprint(dct): - """ - Python 2/3 dict __repr__ may be different, because of unicode differens - (with or without a `u` prefix). Normally in doctests we could use `pprint` - to sort dicts and check for equality, but here we have to write a separate - function to do that. - """ - import pprint - s = pprint.pformat(dct) - print(re.sub("u'", "'", s)) - - -def utf8_repr(func): - """ - ``__repr__`` methods in Python 2 don't allow unicode objects to be - returned. Therefore cast them to utf-8 bytes in this decorator. - """ - def wrapper(self): - result = func(self) - if isinstance(result, unicode): - return result.encode('utf-8') - else: - return result - - if is_py3: - return func - else: - return wrapper diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/__init__.py deleted file mode 100644 index 871dc84..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/__init__.py +++ /dev/null @@ -1,431 +0,0 @@ -""" -The API basically only provides one class. You can create a :class:`Script` and -use its methods. - -Additionally you can add a debug function with :func:`set_debug_function`. -Alternatively, if you don't need a custom function and are happy with printing -debug messages to stdout, simply call :func:`set_debug_function` without -arguments. - -.. warning:: Please, note that Jedi is **not thread safe**. -""" -import os -import sys - -import parso -from parso.python import tree -from parso import python_bytes_to_unicode, split_lines - -from jedi.parser_utils import get_executable_nodes, get_statement_of_position -from jedi import debug -from jedi import settings -from jedi import cache -from jedi.api import classes -from jedi.api import interpreter -from jedi.api import helpers -from jedi.api.completion import Completion -from jedi.evaluate import Evaluator -from jedi.evaluate import imports -from jedi.evaluate import usages -from jedi.evaluate.project import Project -from jedi.evaluate.arguments import try_iter_content -from jedi.evaluate.helpers import get_module_names, evaluate_call_of_leaf -from jedi.evaluate.sys_path import dotted_path_in_sys_path -from jedi.evaluate.filters import TreeNameDefinition -from jedi.evaluate.syntax_tree import tree_name_to_contexts -from jedi.evaluate.context import ModuleContext -from jedi.evaluate.context.module import ModuleName -from jedi.evaluate.context.iterable import unpack_tuple_to_dict - -# Jedi uses lots and lots of recursion. By setting this a little bit higher, we -# can remove some "maximum recursion depth" errors. -sys.setrecursionlimit(3000) - - -class Script(object): - """ - A Script is the base for completions, goto or whatever you want to do with - |jedi|. - - You can either use the ``source`` parameter or ``path`` to read a file. - Usually you're going to want to use both of them (in an editor). - - The script might be analyzed in a different ``sys.path`` than |jedi|: - - - if `sys_path` parameter is not ``None``, it will be used as ``sys.path`` - for the script; - - - if `sys_path` parameter is ``None`` and ``VIRTUAL_ENV`` environment - variable is defined, ``sys.path`` for the specified environment will be - guessed (see :func:`jedi.evaluate.sys_path.get_venv_path`) and used for - the script; - - - otherwise ``sys.path`` will match that of |jedi|. - - :param source: The source code of the current file, separated by newlines. - :type source: str - :param line: The line to perform actions on (starting with 1). - :type line: int - :param column: The column of the cursor (starting with 0). - :type column: int - :param path: The path of the file in the file system, or ``''`` if - it hasn't been saved yet. - :type path: str or None - :param encoding: The encoding of ``source``, if it is not a - ``unicode`` object (default ``'utf-8'``). - :type encoding: str - :param source_encoding: The encoding of ``source``, if it is not a - ``unicode`` object (default ``'utf-8'``). - :type encoding: str - :param sys_path: ``sys.path`` to use during analysis of the script - :type sys_path: list - - """ - def __init__(self, source=None, line=None, column=None, path=None, - encoding='utf-8', sys_path=None): - self._orig_path = path - # An empty path (also empty string) should always result in no path. - self.path = os.path.abspath(path) if path else None - - if source is None: - # TODO add a better warning than the traceback! - with open(path, 'rb') as f: - source = f.read() - - # TODO do we really want that? - self._source = python_bytes_to_unicode(source, encoding, errors='replace') - self._code_lines = split_lines(self._source) - line = max(len(self._code_lines), 1) if line is None else line - if not (0 < line <= len(self._code_lines)): - raise ValueError('`line` parameter is not in a valid range.') - - line_len = len(self._code_lines[line - 1]) - column = line_len if column is None else column - if not (0 <= column <= line_len): - raise ValueError('`column` parameter is not in a valid range.') - self._pos = line, column - self._path = path - - cache.clear_time_caches() - debug.reset_time() - - # Load the Python grammar of the current interpreter. - self._grammar = parso.load_grammar() - project = Project(sys_path=sys_path) - self._evaluator = Evaluator(self._grammar, project) - project.add_script_path(self.path) - debug.speed('init') - - @cache.memoize_method - def _get_module_node(self): - return self._grammar.parse( - code=self._source, - path=self.path, - cache=False, # No disk cache, because the current script often changes. - diff_cache=True, - cache_path=settings.cache_directory - ) - - @cache.memoize_method - def _get_module(self): - module = ModuleContext( - self._evaluator, - self._get_module_node(), - self.path - ) - if self.path is not None: - name = dotted_path_in_sys_path(self._evaluator.project.sys_path, self.path) - if name is not None: - imports.add_module(self._evaluator, name, module) - return module - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, repr(self._orig_path)) - - def completions(self): - """ - Return :class:`classes.Completion` objects. Those objects contain - information about the completions, more than just names. - - :return: Completion objects, sorted by name and __ comes last. - :rtype: list of :class:`classes.Completion` - """ - debug.speed('completions start') - completion = Completion( - self._evaluator, self._get_module(), self._code_lines, - self._pos, self.call_signatures - ) - completions = completion.completions() - debug.speed('completions end') - return completions - - def goto_definitions(self): - """ - Return the definitions of a the path under the cursor. goto function! - This follows complicated paths and returns the end, not the first - definition. The big difference between :meth:`goto_assignments` and - :meth:`goto_definitions` is that :meth:`goto_assignments` doesn't - follow imports and statements. Multiple objects may be returned, - because Python itself is a dynamic language, which means depending on - an option you can have two different versions of a function. - - :rtype: list of :class:`classes.Definition` - """ - module_node = self._get_module_node() - leaf = module_node.get_name_of_position(self._pos) - if leaf is None: - leaf = module_node.get_leaf_for_position(self._pos) - if leaf is None: - return [] - - context = self._evaluator.create_context(self._get_module(), leaf) - definitions = helpers.evaluate_goto_definition(self._evaluator, context, leaf) - - names = [s.name for s in definitions] - defs = [classes.Definition(self._evaluator, name) for name in names] - # The additional set here allows the definitions to become unique in an - # API sense. In the internals we want to separate more things than in - # the API. - return helpers.sorted_definitions(set(defs)) - - def goto_assignments(self, follow_imports=False): - """ - Return the first definition found, while optionally following imports. - Multiple objects may be returned, because Python itself is a - dynamic language, which means depending on an option you can have two - different versions of a function. - - :rtype: list of :class:`classes.Definition` - """ - def filter_follow_imports(names, check): - for name in names: - if check(name): - for result in filter_follow_imports(name.goto(), check): - yield result - else: - yield name - - tree_name = self._get_module_node().get_name_of_position(self._pos) - if tree_name is None: - return [] - context = self._evaluator.create_context(self._get_module(), tree_name) - names = list(self._evaluator.goto(context, tree_name)) - - if follow_imports: - def check(name): - if isinstance(name, ModuleName): - return False - return name.api_type == 'module' - else: - def check(name): - return isinstance(name, imports.SubModuleName) - - names = filter_follow_imports(names, check) - - defs = [classes.Definition(self._evaluator, d) for d in set(names)] - return helpers.sorted_definitions(defs) - - def usages(self, additional_module_paths=()): - """ - Return :class:`classes.Definition` objects, which contain all - names that point to the definition of the name under the cursor. This - is very useful for refactoring (renaming), or to show all usages of a - variable. - - .. todo:: Implement additional_module_paths - - :rtype: list of :class:`classes.Definition` - """ - tree_name = self._get_module_node().get_name_of_position(self._pos) - if tree_name is None: - # Must be syntax - return [] - - names = usages.usages(self._get_module(), tree_name) - - definitions = [classes.Definition(self._evaluator, n) for n in names] - return helpers.sorted_definitions(definitions) - - def call_signatures(self): - """ - Return the function object of the call you're currently in. - - E.g. if the cursor is here:: - - abs(# <-- cursor is here - - This would return the ``abs`` function. On the other hand:: - - abs()# <-- cursor is here - - This would return an empty list.. - - :rtype: list of :class:`classes.CallSignature` - """ - call_signature_details = \ - helpers.get_call_signature_details(self._get_module_node(), self._pos) - if call_signature_details is None: - return [] - - context = self._evaluator.create_context( - self._get_module(), - call_signature_details.bracket_leaf - ) - definitions = helpers.cache_call_signatures( - self._evaluator, - context, - call_signature_details.bracket_leaf, - self._code_lines, - self._pos - ) - debug.speed('func_call followed') - - return [classes.CallSignature(self._evaluator, d.name, - call_signature_details.bracket_leaf.start_pos, - call_signature_details.call_index, - call_signature_details.keyword_name_str) - for d in definitions if hasattr(d, 'py__call__')] - - def _analysis(self): - self._evaluator.is_analysis = True - module_node = self._get_module_node() - self._evaluator.analysis_modules = [module_node] - try: - for node in get_executable_nodes(module_node): - context = self._get_module().create_context(node) - if node.type in ('funcdef', 'classdef'): - # Resolve the decorators. - tree_name_to_contexts(self._evaluator, context, node.children[1]) - elif isinstance(node, tree.Import): - import_names = set(node.get_defined_names()) - if node.is_nested(): - import_names |= set(path[-1] for path in node.get_paths()) - for n in import_names: - imports.infer_import(context, n) - elif node.type == 'expr_stmt': - types = context.eval_node(node) - for testlist in node.children[:-1:2]: - # Iterate tuples. - unpack_tuple_to_dict(context, types, testlist) - else: - if node.type == 'name': - defs = self._evaluator.goto_definitions(context, node) - else: - defs = evaluate_call_of_leaf(context, node) - try_iter_content(defs) - self._evaluator.reset_recursion_limitations() - - ana = [a for a in self._evaluator.analysis if self.path == a.path] - return sorted(set(ana), key=lambda x: x.line) - finally: - self._evaluator.is_analysis = False - - -class Interpreter(Script): - """ - Jedi API for Python REPLs. - - In addition to completion of simple attribute access, Jedi - supports code completion based on static code analysis. - Jedi can complete attributes of object which is not initialized - yet. - - >>> from os.path import join - >>> namespace = locals() - >>> script = Interpreter('join("").up', [namespace]) - >>> print(script.completions()[0].name) - upper - """ - - def __init__(self, source, namespaces, **kwds): - """ - Parse `source` and mixin interpreted Python objects from `namespaces`. - - :type source: str - :arg source: Code to parse. - :type namespaces: list of dict - :arg namespaces: a list of namespace dictionaries such as the one - returned by :func:`locals`. - - Other optional arguments are same as the ones for :class:`Script`. - If `line` and `column` are None, they are assumed be at the end of - `source`. - """ - try: - namespaces = [dict(n) for n in namespaces] - except Exception: - raise TypeError("namespaces must be a non-empty list of dicts.") - - super(Interpreter, self).__init__(source, **kwds) - self.namespaces = namespaces - - def _get_module(self): - parser_module = super(Interpreter, self)._get_module_node() - return interpreter.MixedModuleContext( - self._evaluator, - parser_module, - self.namespaces, - path=self.path - ) - - -def names(source=None, path=None, encoding='utf-8', all_scopes=False, - definitions=True, references=False): - """ - Returns a list of `Definition` objects, containing name parts. - This means you can call ``Definition.goto_assignments()`` and get the - reference of a name. - The parameters are the same as in :py:class:`Script`, except or the - following ones: - - :param all_scopes: If True lists the names of all scopes instead of only - the module namespace. - :param definitions: If True lists the names that have been defined by a - class, function or a statement (``a = b`` returns ``a``). - :param references: If True lists all the names that are not listed by - ``definitions=True``. E.g. ``a = b`` returns ``b``. - """ - def def_ref_filter(_def): - is_def = _def._name.tree_name.is_definition() - return definitions and is_def or references and not is_def - - # Set line/column to a random position, because they don't matter. - script = Script(source, line=1, column=0, path=path, encoding=encoding) - module_context = script._get_module() - defs = [ - classes.Definition( - script._evaluator, - TreeNameDefinition( - module_context.create_context(name if name.parent.type == 'file_input' else name.parent), - name - ) - ) for name in get_module_names(script._get_module_node(), all_scopes) - ] - return sorted(filter(def_ref_filter, defs), key=lambda x: (x.line, x.column)) - - -def preload_module(*modules): - """ - Preloading modules tells Jedi to load a module now, instead of lazy parsing - of modules. Usful for IDEs, to control which modules to load on startup. - - :param modules: different module names, list of string. - """ - for m in modules: - s = "import %s as x; x." % m - Script(s, 1, len(s), None).completions() - - -def set_debug_function(func_cb=debug.print_to_stdout, warnings=True, - notices=True, speed=True): - """ - Define a callback debug function to get all the debug messages. - - If you don't specify any arguments, debug messages will be printed to stdout. - - :param func_cb: The callback function for debug messages, with n params. - """ - debug.debug_function = func_cb - debug.enable_warning = warnings - debug.enable_notice = notices - debug.enable_speed = speed diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/classes.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/classes.py deleted file mode 100644 index 1937cc6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/classes.py +++ /dev/null @@ -1,678 +0,0 @@ -""" -The :mod:`jedi.api.classes` module contains the return classes of the API. -These classes are the much bigger part of the whole API, because they contain -the interesting information about completion and goto operations. -""" -import re - -from parso.cache import parser_cache -from parso.python.tree import search_ancestor - -from jedi._compatibility import u -from jedi import settings -from jedi.evaluate.utils import ignored, unite -from jedi.cache import memoize_method -from jedi.evaluate import imports -from jedi.evaluate import compiled -from jedi.evaluate.filters import ParamName -from jedi.evaluate.imports import ImportName -from jedi.evaluate.context import instance -from jedi.evaluate.context import ClassContext, FunctionContext, FunctionExecutionContext -from jedi.api.keywords import KeywordName - - -def _sort_names_by_start_pos(names): - return sorted(names, key=lambda s: s.start_pos or (0, 0)) - - -def defined_names(evaluator, context): - """ - List sub-definitions (e.g., methods in class). - - :type scope: Scope - :rtype: list of Definition - """ - filter = next(context.get_filters(search_global=True)) - names = [name for name in filter.values()] - return [Definition(evaluator, n) for n in _sort_names_by_start_pos(names)] - - -class BaseDefinition(object): - _mapping = { - 'posixpath': 'os.path', - 'riscospath': 'os.path', - 'ntpath': 'os.path', - 'os2emxpath': 'os.path', - 'macpath': 'os.path', - 'genericpath': 'os.path', - 'posix': 'os', - '_io': 'io', - '_functools': 'functools', - '_sqlite3': 'sqlite3', - '__builtin__': '', - 'builtins': '', - } - - _tuple_mapping = dict((tuple(k.split('.')), v) for (k, v) in { - 'argparse._ActionsContainer': 'argparse.ArgumentParser', - }.items()) - - def __init__(self, evaluator, name): - self._evaluator = evaluator - self._name = name - """ - An instance of :class:`parso.reprsentation.Name` subclass. - """ - self.is_keyword = isinstance(self._name, KeywordName) - - # generate a path to the definition - self._module = name.get_root_context() - if self.in_builtin_module(): - self.module_path = None - else: - self.module_path = self._module.py__file__() - """Shows the file path of a module. e.g. ``/usr/lib/python2.7/os.py``""" - - @property - def name(self): - """ - Name of variable/function/class/module. - - For example, for ``x = None`` it returns ``'x'``. - - :rtype: str or None - """ - return self._name.string_name - - @property - def type(self): - """ - The type of the definition. - - Here is an example of the value of this attribute. Let's consider - the following source. As what is in ``variable`` is unambiguous - to Jedi, :meth:`jedi.Script.goto_definitions` should return a list of - definition for ``sys``, ``f``, ``C`` and ``x``. - - >>> from jedi import Script - >>> source = ''' - ... import keyword - ... - ... class C: - ... pass - ... - ... class D: - ... pass - ... - ... x = D() - ... - ... def f(): - ... pass - ... - ... for variable in [keyword, f, C, x]: - ... variable''' - - >>> script = Script(source) - >>> defs = script.goto_definitions() - - Before showing what is in ``defs``, let's sort it by :attr:`line` - so that it is easy to relate the result to the source code. - - >>> defs = sorted(defs, key=lambda d: d.line) - >>> defs # doctest: +NORMALIZE_WHITESPACE - [, , - , ] - - Finally, here is what you can get from :attr:`type`: - - >>> defs[0].type - 'module' - >>> defs[1].type - 'class' - >>> defs[2].type - 'instance' - >>> defs[3].type - 'function' - - """ - tree_name = self._name.tree_name - resolve = False - if tree_name is not None: - # TODO move this to their respective names. - definition = tree_name.get_definition() - if definition is not None and definition.type == 'import_from' and \ - tree_name.is_definition(): - resolve = True - - if isinstance(self._name, imports.SubModuleName) or resolve: - for context in self._name.infer(): - return context.api_type - return self._name.api_type - - def _path(self): - """The path to a module/class/function definition.""" - def to_reverse(): - name = self._name - if name.api_type == 'module': - try: - name = list(name.infer())[0].name - except IndexError: - pass - - if name.api_type == 'module': - module_contexts = name.infer() - if module_contexts: - module_context, = module_contexts - for n in reversed(module_context.py__name__().split('.')): - yield n - else: - # We don't really know anything about the path here. This - # module is just an import that would lead in an - # ImportError. So simply return the name. - yield name.string_name - return - else: - yield name.string_name - - parent_context = name.parent_context - while parent_context is not None: - try: - method = parent_context.py__name__ - except AttributeError: - try: - yield parent_context.name.string_name - except AttributeError: - pass - else: - for name in reversed(method().split('.')): - yield name - parent_context = parent_context.parent_context - return reversed(list(to_reverse())) - - @property - def module_name(self): - """ - The module name. - - >>> from jedi import Script - >>> source = 'import json' - >>> script = Script(source, path='example.py') - >>> d = script.goto_definitions()[0] - >>> print(d.module_name) # doctest: +ELLIPSIS - json - """ - return self._module.name.string_name - - def in_builtin_module(self): - """Whether this is a builtin module.""" - return isinstance(self._module, compiled.CompiledObject) - - @property - def line(self): - """The line where the definition occurs (starting with 1).""" - start_pos = self._name.start_pos - if start_pos is None: - return None - return start_pos[0] - - @property - def column(self): - """The column where the definition occurs (starting with 0).""" - start_pos = self._name.start_pos - if start_pos is None: - return None - return start_pos[1] - - def docstring(self, raw=False, fast=True): - r""" - Return a document string for this completion object. - - Example: - - >>> from jedi import Script - >>> source = '''\ - ... def f(a, b=1): - ... "Document for function f." - ... ''' - >>> script = Script(source, 1, len('def f'), 'example.py') - >>> doc = script.goto_definitions()[0].docstring() - >>> print(doc) - f(a, b=1) - - Document for function f. - - Notice that useful extra information is added to the actual - docstring. For function, it is call signature. If you need - actual docstring, use ``raw=True`` instead. - - >>> print(script.goto_definitions()[0].docstring(raw=True)) - Document for function f. - - :param fast: Don't follow imports that are only one level deep like - ``import foo``, but follow ``from foo import bar``. This makes - sense for speed reasons. Completing `import a` is slow if you use - the ``foo.docstring(fast=False)`` on every object, because it - parses all libraries starting with ``a``. - """ - return _Help(self._name).docstring(fast=fast, raw=raw) - - @property - def description(self): - """A textual description of the object.""" - return u(self._name.string_name) - - @property - def full_name(self): - """ - Dot-separated path of this object. - - It is in the form of ``[.[...]][.]``. - It is useful when you want to look up Python manual of the - object at hand. - - Example: - - >>> from jedi import Script - >>> source = ''' - ... import os - ... os.path.join''' - >>> script = Script(source, 3, len('os.path.join'), 'example.py') - >>> print(script.goto_definitions()[0].full_name) - os.path.join - - Notice that it returns ``'os.path.join'`` instead of (for example) - ``'posixpath.join'``. This is not correct, since the modules name would - be `````. However most users find the latter - more practical. - """ - path = list(self._path()) - # TODO add further checks, the mapping should only occur on stdlib. - if not path: - return None # for keywords the path is empty - - with ignored(KeyError): - path[0] = self._mapping[path[0]] - for key, repl in self._tuple_mapping.items(): - if tuple(path[:len(key)]) == key: - path = [repl] + path[len(key):] - - return '.'.join(path if path[0] else path[1:]) - - def goto_assignments(self): - if self._name.tree_name is None: - return self - - names = self._evaluator.goto(self._name.parent_context, self._name.tree_name) - return [Definition(self._evaluator, n) for n in names] - - def _goto_definitions(self): - # TODO make this function public. - return [Definition(self._evaluator, d.name) for d in self._name.infer()] - - @property - @memoize_method - def params(self): - """ - Raises an ``AttributeError``if the definition is not callable. - Otherwise returns a list of `Definition` that represents the params. - """ - def get_param_names(context): - param_names = [] - if context.api_type == 'function': - param_names = list(context.get_param_names()) - if isinstance(context, instance.BoundMethod): - param_names = param_names[1:] - elif isinstance(context, (instance.AbstractInstanceContext, ClassContext)): - if isinstance(context, ClassContext): - search = '__init__' - else: - search = '__call__' - names = context.get_function_slot_names(search) - if not names: - return [] - - # Just take the first one here, not optimal, but currently - # there's no better solution. - inferred = names[0].infer() - param_names = get_param_names(next(iter(inferred))) - if isinstance(context, ClassContext): - param_names = param_names[1:] - return param_names - elif isinstance(context, compiled.CompiledObject): - return list(context.get_param_names()) - return param_names - - followed = list(self._name.infer()) - if not followed or not hasattr(followed[0], 'py__call__'): - raise AttributeError() - context = followed[0] # only check the first one. - - return [Definition(self._evaluator, n) for n in get_param_names(context)] - - def parent(self): - context = self._name.parent_context - if context is None: - return None - - if isinstance(context, FunctionExecutionContext): - # TODO the function context should be a part of the function - # execution context. - context = FunctionContext( - self._evaluator, context.parent_context, context.tree_node) - return Definition(self._evaluator, context.name) - - def __repr__(self): - return "<%s %s>" % (type(self).__name__, self.description) - - def get_line_code(self, before=0, after=0): - """ - Returns the line of code where this object was defined. - - :param before: Add n lines before the current line to the output. - :param after: Add n lines after the current line to the output. - - :return str: Returns the line(s) of code or an empty string if it's a - builtin. - """ - if self.in_builtin_module(): - return '' - - path = self._name.get_root_context().py__file__() - lines = parser_cache[self._evaluator.grammar._hashed][path].lines - - index = self._name.start_pos[0] - 1 - start_index = max(index - before, 0) - return ''.join(lines[start_index:index + after + 1]) - - -class Completion(BaseDefinition): - """ - `Completion` objects are returned from :meth:`api.Script.completions`. They - provide additional information about a completion. - """ - def __init__(self, evaluator, name, stack, like_name_length): - super(Completion, self).__init__(evaluator, name) - - self._like_name_length = like_name_length - self._stack = stack - - # Completion objects with the same Completion name (which means - # duplicate items in the completion) - self._same_name_completions = [] - - def _complete(self, like_name): - append = '' - if settings.add_bracket_after_function \ - and self.type == 'Function': - append = '(' - - if isinstance(self._name, ParamName) and self._stack is not None: - node_names = list(self._stack.get_node_names(self._evaluator.grammar._pgen_grammar)) - if 'trailer' in node_names and 'argument' not in node_names: - append += '=' - - name = self._name.string_name - if like_name: - name = name[self._like_name_length:] - return name + append - - @property - def complete(self): - """ - Return the rest of the word, e.g. completing ``isinstance``:: - - isinstan# <-- Cursor is here - - would return the string 'ce'. It also adds additional stuff, depending - on your `settings.py`. - - Assuming the following function definition:: - - def foo(param=0): - pass - - completing ``foo(par`` would give a ``Completion`` which `complete` - would be `am=` - - - """ - return self._complete(True) - - @property - def name_with_symbols(self): - """ - Similar to :attr:`name`, but like :attr:`name` returns also the - symbols, for example assuming the following function definition:: - - def foo(param=0): - pass - - completing ``foo(`` would give a ``Completion`` which - ``name_with_symbols`` would be "param=". - - """ - return self._complete(False) - - def docstring(self, raw=False, fast=True): - if self._like_name_length >= 3: - # In this case we can just resolve the like name, because we - # wouldn't load like > 100 Python modules anymore. - fast = False - return super(Completion, self).docstring(raw=raw, fast=fast) - - @property - def description(self): - """Provide a description of the completion object.""" - # TODO improve the class structure. - return Definition.description.__get__(self) - - def __repr__(self): - return '<%s: %s>' % (type(self).__name__, self._name.string_name) - - @memoize_method - def follow_definition(self): - """ - Return the original definitions. I strongly recommend not using it for - your completions, because it might slow down |jedi|. If you want to - read only a few objects (<=20), it might be useful, especially to get - the original docstrings. The basic problem of this function is that it - follows all results. This means with 1000 completions (e.g. numpy), - it's just PITA-slow. - """ - defs = self._name.infer() - return [Definition(self._evaluator, d.name) for d in defs] - - -class Definition(BaseDefinition): - """ - *Definition* objects are returned from :meth:`api.Script.goto_assignments` - or :meth:`api.Script.goto_definitions`. - """ - def __init__(self, evaluator, definition): - super(Definition, self).__init__(evaluator, definition) - - @property - def description(self): - """ - A description of the :class:`.Definition` object, which is heavily used - in testing. e.g. for ``isinstance`` it returns ``def isinstance``. - - Example: - - >>> from jedi import Script - >>> source = ''' - ... def f(): - ... pass - ... - ... class C: - ... pass - ... - ... variable = f if random.choice([0,1]) else C''' - >>> script = Script(source, column=3) # line is maximum by default - >>> defs = script.goto_definitions() - >>> defs = sorted(defs, key=lambda d: d.line) - >>> defs - [, ] - >>> str(defs[0].description) # strip literals in python2 - 'def f' - >>> str(defs[1].description) - 'class C' - - """ - typ = self.type - tree_name = self._name.tree_name - if typ in ('function', 'class', 'module', 'instance') or tree_name is None: - if typ == 'function': - # For the description we want a short and a pythonic way. - typ = 'def' - return typ + ' ' + u(self._name.string_name) - elif typ == 'param': - code = search_ancestor(tree_name, 'param').get_code( - include_prefix=False, - include_comma=False - ) - return typ + ' ' + code - - - definition = tree_name.get_definition() or tree_name - # Remove the prefix, because that's not what we want for get_code - # here. - txt = definition.get_code(include_prefix=False) - # Delete comments: - txt = re.sub('#[^\n]+\n', ' ', txt) - # Delete multi spaces/newlines - txt = re.sub('\s+', ' ', txt).strip() - return txt - - @property - def desc_with_module(self): - """ - In addition to the definition, also return the module. - - .. warning:: Don't use this function yet, its behaviour may change. If - you really need it, talk to me. - - .. todo:: Add full path. This function is should return a - `module.class.function` path. - """ - position = '' if self.in_builtin_module else '@%s' % (self.line) - return "%s:%s%s" % (self.module_name, self.description, position) - - @memoize_method - def defined_names(self): - """ - List sub-definitions (e.g., methods in class). - - :rtype: list of Definition - """ - defs = self._name.infer() - return sorted( - unite(defined_names(self._evaluator, d) for d in defs), - key=lambda s: s._name.start_pos or (0, 0) - ) - - def is_definition(self): - """ - Returns True, if defined as a name in a statement, function or class. - Returns False, if it's a reference to such a definition. - """ - if self._name.tree_name is None: - return True - else: - return self._name.tree_name.is_definition() - - def __eq__(self, other): - return self._name.start_pos == other._name.start_pos \ - and self.module_path == other.module_path \ - and self.name == other.name \ - and self._evaluator == other._evaluator - - def __ne__(self, other): - return not self.__eq__(other) - - def __hash__(self): - return hash((self._name.start_pos, self.module_path, self.name, self._evaluator)) - - -class CallSignature(Definition): - """ - `CallSignature` objects is the return value of `Script.function_definition`. - It knows what functions you are currently in. e.g. `isinstance(` would - return the `isinstance` function. without `(` it would return nothing. - """ - def __init__(self, evaluator, executable_name, bracket_start_pos, index, key_name_str): - super(CallSignature, self).__init__(evaluator, executable_name) - self._index = index - self._key_name_str = key_name_str - self._bracket_start_pos = bracket_start_pos - - @property - def index(self): - """ - The Param index of the current call. - Returns None if the index cannot be found in the curent call. - """ - if self._key_name_str is not None: - for i, param in enumerate(self.params): - if self._key_name_str == param.name: - return i - if self.params: - param_name = self.params[-1]._name - if param_name.tree_name is not None: - if param_name.tree_name.get_definition().star_count == 2: - return i - return None - - if self._index >= len(self.params): - for i, param in enumerate(self.params): - tree_name = param._name.tree_name - if tree_name is not None: - # *args case - if tree_name.get_definition().star_count == 1: - return i - return None - return self._index - - @property - def bracket_start(self): - """ - The indent of the bracket that is responsible for the last function - call. - """ - return self._bracket_start_pos - - def __repr__(self): - return '<%s: %s index %s>' % \ - (type(self).__name__, self._name.string_name, self.index) - - -class _Help(object): - """ - Temporary implementation, will be used as `Script.help() or something in - the future. - """ - def __init__(self, definition): - self._name = definition - - @memoize_method - def _get_contexts(self, fast): - if isinstance(self._name, ImportName) and fast: - return {} - - if self._name.api_type == 'statement': - return {} - - return self._name.infer() - - def docstring(self, fast=True, raw=True): - """ - The docstring ``__doc__`` for any object. - - See :attr:`doc` for example. - """ - # TODO: Use all of the followed objects as output. Possibly divinding - # them by a few dashes. - for context in self._get_contexts(fast=fast): - return context.py__doc__(include_call_signature=not raw) - - return '' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/completion.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/completion.py deleted file mode 100644 index 559a4d3..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/completion.py +++ /dev/null @@ -1,291 +0,0 @@ -from parso.python import token -from parso.python import tree -from parso.tree import search_ancestor, Leaf - -from jedi import debug -from jedi import settings -from jedi.api import classes -from jedi.api import helpers -from jedi.evaluate import imports -from jedi.api import keywords -from jedi.evaluate.helpers import evaluate_call_of_leaf -from jedi.evaluate.filters import get_global_filters -from jedi.parser_utils import get_statement_of_position - - -def get_call_signature_param_names(call_signatures): - # add named params - for call_sig in call_signatures: - for p in call_sig.params: - # Allow protected access, because it's a public API. - tree_name = p._name.tree_name - # Compiled modules typically don't allow keyword arguments. - if tree_name is not None: - # Allow access on _definition here, because it's a - # public API and we don't want to make the internal - # Name object public. - tree_param = tree.search_ancestor(tree_name, 'param') - if tree_param.star_count == 0: # no *args/**kwargs - yield p._name - - -def filter_names(evaluator, completion_names, stack, like_name): - comp_dct = {} - for name in completion_names: - if settings.case_insensitive_completion \ - and name.string_name.lower().startswith(like_name.lower()) \ - or name.string_name.startswith(like_name): - - new = classes.Completion( - evaluator, - name, - stack, - len(like_name) - ) - k = (new.name, new.complete) # key - if k in comp_dct and settings.no_completion_duplicates: - comp_dct[k]._same_name_completions.append(new) - else: - comp_dct[k] = new - yield new - - -def get_user_scope(module_context, position): - """ - Returns the scope in which the user resides. This includes flows. - """ - user_stmt = get_statement_of_position(module_context.tree_node, position) - if user_stmt is None: - def scan(scope): - for s in scope.children: - if s.start_pos <= position <= s.end_pos: - if isinstance(s, (tree.Scope, tree.Flow)): - return scan(s) or s - elif s.type in ('suite', 'decorated'): - return scan(s) - return None - - scanned_node = scan(module_context.tree_node) - if scanned_node: - return module_context.create_context(scanned_node, node_is_context=True) - return module_context - else: - return module_context.create_context(user_stmt) - - -def get_flow_scope_node(module_node, position): - node = module_node.get_leaf_for_position(position, include_prefixes=True) - while not isinstance(node, (tree.Scope, tree.Flow)): - node = node.parent - - return node - - -class Completion: - def __init__(self, evaluator, module, code_lines, position, call_signatures_method): - self._evaluator = evaluator - self._module_context = module - self._module_node = module.tree_node - self._code_lines = code_lines - - # The first step of completions is to get the name - self._like_name = helpers.get_on_completion_name(self._module_node, code_lines, position) - # The actual cursor position is not what we need to calculate - # everything. We want the start of the name we're on. - self._position = position[0], position[1] - len(self._like_name) - self._call_signatures_method = call_signatures_method - - def completions(self): - completion_names = self._get_context_completions() - - completions = filter_names(self._evaluator, completion_names, - self.stack, self._like_name) - - return sorted(completions, key=lambda x: (x.name.startswith('__'), - x.name.startswith('_'), - x.name.lower())) - - def _get_context_completions(self): - """ - Analyzes the context that a completion is made in and decides what to - return. - - Technically this works by generating a parser stack and analysing the - current stack for possible grammar nodes. - - Possible enhancements: - - global/nonlocal search global - - yield from / raise from <- could be only exceptions/generators - - In args: */**: no completion - - In params (also lambda): no completion before = - """ - - grammar = self._evaluator.grammar - - try: - self.stack = helpers.get_stack_at_position( - grammar, self._code_lines, self._module_node, self._position - ) - except helpers.OnErrorLeaf as e: - self.stack = None - if e.error_leaf.value == '.': - # After ErrorLeaf's that are dots, we will not do any - # completions since this probably just confuses the user. - return [] - # If we don't have a context, just use global completion. - - return self._global_completions() - - allowed_keywords, allowed_tokens = \ - helpers.get_possible_completion_types(grammar._pgen_grammar, self.stack) - - if 'if' in allowed_keywords: - leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True) - previous_leaf = leaf.get_previous_leaf() - - indent = self._position[1] - if not (leaf.start_pos <= self._position <= leaf.end_pos): - indent = leaf.start_pos[1] - - if previous_leaf is not None: - stmt = previous_leaf - while True: - stmt = search_ancestor( - stmt, 'if_stmt', 'for_stmt', 'while_stmt', 'try_stmt', - 'error_node', - ) - if stmt is None: - break - - type_ = stmt.type - if type_ == 'error_node': - first = stmt.children[0] - if isinstance(first, Leaf): - type_ = first.value + '_stmt' - # Compare indents - if stmt.start_pos[1] == indent: - if type_ == 'if_stmt': - allowed_keywords += ['elif', 'else'] - elif type_ == 'try_stmt': - allowed_keywords += ['except', 'finally', 'else'] - elif type_ == 'for_stmt': - allowed_keywords.append('else') - - completion_names = list(self._get_keyword_completion_names(allowed_keywords)) - - if token.NAME in allowed_tokens or token.INDENT in allowed_tokens: - # This means that we actually have to do type inference. - - symbol_names = list(self.stack.get_node_names(grammar._pgen_grammar)) - - nodes = list(self.stack.get_nodes()) - - if nodes and nodes[-1] in ('as', 'def', 'class'): - # No completions for ``with x as foo`` and ``import x as foo``. - # Also true for defining names as a class or function. - return list(self._get_class_context_completions(is_function=True)) - elif "import_stmt" in symbol_names: - level, names = self._parse_dotted_names(nodes, "import_from" in symbol_names) - - only_modules = not ("import_from" in symbol_names and 'import' in nodes) - completion_names += self._get_importer_names( - names, - level, - only_modules=only_modules, - ) - elif symbol_names[-1] in ('trailer', 'dotted_name') and nodes[-1] == '.': - dot = self._module_node.get_leaf_for_position(self._position) - completion_names += self._trailer_completions(dot.get_previous_leaf()) - else: - completion_names += self._global_completions() - completion_names += self._get_class_context_completions(is_function=False) - - if 'trailer' in symbol_names: - call_signatures = self._call_signatures_method() - completion_names += get_call_signature_param_names(call_signatures) - - return completion_names - - def _get_keyword_completion_names(self, keywords_): - for k in keywords_: - yield keywords.keyword(self._evaluator, k).name - - def _global_completions(self): - context = get_user_scope(self._module_context, self._position) - debug.dbg('global completion scope: %s', context) - flow_scope_node = get_flow_scope_node(self._module_node, self._position) - filters = get_global_filters( - self._evaluator, - context, - self._position, - origin_scope=flow_scope_node - ) - completion_names = [] - for filter in filters: - completion_names += filter.values() - return completion_names - - def _trailer_completions(self, previous_leaf): - user_context = get_user_scope(self._module_context, self._position) - evaluation_context = self._evaluator.create_context( - self._module_context, previous_leaf - ) - contexts = evaluate_call_of_leaf(evaluation_context, previous_leaf) - completion_names = [] - debug.dbg('trailer completion contexts: %s', contexts) - for context in contexts: - for filter in context.get_filters( - search_global=False, origin_scope=user_context.tree_node): - completion_names += filter.values() - return completion_names - - def _parse_dotted_names(self, nodes, is_import_from): - level = 0 - names = [] - for node in nodes[1:]: - if node in ('.', '...'): - if not names: - level += len(node.value) - elif node.type == 'dotted_name': - names += node.children[::2] - elif node.type == 'name': - names.append(node) - elif node == ',': - if not is_import_from: - names = [] - else: - # Here if the keyword `import` comes along it stops checking - # for names. - break - return level, names - - def _get_importer_names(self, names, level=0, only_modules=True): - names = [n.value for n in names] - i = imports.Importer(self._evaluator, names, self._module_context, level) - return i.completion_names(self._evaluator, only_modules=only_modules) - - def _get_class_context_completions(self, is_function=True): - """ - Autocomplete inherited methods when overriding in child class. - """ - leaf = self._module_node.get_leaf_for_position(self._position, include_prefixes=True) - cls = tree.search_ancestor(leaf, 'classdef') - if isinstance(cls, (tree.Class, tree.Function)): - # Complete the methods that are defined in the super classes. - random_context = self._module_context.create_context( - cls, - node_is_context=True - ) - else: - return - - if cls.start_pos[1] >= leaf.start_pos[1]: - return - - filters = random_context.get_filters(search_global=False, is_instance=True) - # The first dict is the dictionary of class itself. - next(filters) - for filter in filters: - for name in filter.values(): - if (name.api_type == 'function') == is_function: - yield name diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/helpers.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/helpers.py deleted file mode 100644 index 2c4d8e0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/helpers.py +++ /dev/null @@ -1,316 +0,0 @@ -""" -Helpers for the API -""" -import re -from collections import namedtuple -from textwrap import dedent - -from parso.python.parser import Parser -from parso.python import tree -from parso import split_lines - -from jedi._compatibility import u -from jedi.evaluate.syntax_tree import eval_atom -from jedi.evaluate.helpers import evaluate_call_of_leaf -from jedi.cache import time_cache - - -CompletionParts = namedtuple('CompletionParts', ['path', 'has_dot', 'name']) - - -def sorted_definitions(defs): - # Note: `or ''` below is required because `module_path` could be - return sorted(defs, key=lambda x: (x.module_path or '', x.line or 0, x.column or 0)) - - -def get_on_completion_name(module_node, lines, position): - leaf = module_node.get_leaf_for_position(position) - if leaf is None or leaf.type in ('string', 'error_leaf'): - # Completions inside strings are a bit special, we need to parse the - # string. The same is true for comments and error_leafs. - line = lines[position[0] - 1] - # The first step of completions is to get the name - return re.search(r'(?!\d)\w+$|$', line[:position[1]]).group(0) - elif leaf.type not in ('name', 'keyword'): - return '' - - return leaf.value[:position[1] - leaf.start_pos[1]] - - -def _get_code(code_lines, start_pos, end_pos): - # Get relevant lines. - lines = code_lines[start_pos[0] - 1:end_pos[0]] - # Remove the parts at the end of the line. - lines[-1] = lines[-1][:end_pos[1]] - # Remove first line indentation. - lines[0] = lines[0][start_pos[1]:] - return '\n'.join(lines) - - -class OnErrorLeaf(Exception): - @property - def error_leaf(self): - return self.args[0] - - -def _is_on_comment(leaf, position): - comment_lines = split_lines(leaf.prefix) - difference = leaf.start_pos[0] - position[0] - prefix_start_pos = leaf.get_start_pos_of_prefix() - if difference == 0: - indent = leaf.start_pos[1] - elif position[0] == prefix_start_pos[0]: - indent = prefix_start_pos[1] - else: - indent = 0 - line = comment_lines[-difference - 1][:position[1] - indent] - return '#' in line - - -def _get_code_for_stack(code_lines, module_node, position): - leaf = module_node.get_leaf_for_position(position, include_prefixes=True) - # It might happen that we're on whitespace or on a comment. This means - # that we would not get the right leaf. - if leaf.start_pos >= position: - if _is_on_comment(leaf, position): - return u('') - - # If we're not on a comment simply get the previous leaf and proceed. - leaf = leaf.get_previous_leaf() - if leaf is None: - return u('') # At the beginning of the file. - - is_after_newline = leaf.type == 'newline' - while leaf.type == 'newline': - leaf = leaf.get_previous_leaf() - if leaf is None: - return u('') - - if leaf.type == 'error_leaf' or leaf.type == 'string': - if leaf.start_pos[0] < position[0]: - # On a different line, we just begin anew. - return u('') - - # Error leafs cannot be parsed, completion in strings is also - # impossible. - raise OnErrorLeaf(leaf) - else: - user_stmt = leaf - while True: - if user_stmt.parent.type in ('file_input', 'suite', 'simple_stmt'): - break - user_stmt = user_stmt.parent - - if is_after_newline: - if user_stmt.start_pos[1] > position[1]: - # This means that it's actually a dedent and that means that we - # start without context (part of a suite). - return u('') - - # This is basically getting the relevant lines. - return _get_code(code_lines, user_stmt.get_start_pos_of_prefix(), position) - - -def get_stack_at_position(grammar, code_lines, module_node, pos): - """ - Returns the possible node names (e.g. import_from, xor_test or yield_stmt). - """ - class EndMarkerReached(Exception): - pass - - def tokenize_without_endmarker(code): - # TODO This is for now not an official parso API that exists purely - # for Jedi. - tokens = grammar._tokenize(code) - for token_ in tokens: - if token_.string == safeword: - raise EndMarkerReached() - else: - yield token_ - - # The code might be indedented, just remove it. - code = dedent(_get_code_for_stack(code_lines, module_node, pos)) - # We use a word to tell Jedi when we have reached the start of the - # completion. - # Use Z as a prefix because it's not part of a number suffix. - safeword = 'ZZZ_USER_WANTS_TO_COMPLETE_HERE_WITH_JEDI' - code = code + safeword - - p = Parser(grammar._pgen_grammar, error_recovery=True) - try: - p.parse(tokens=tokenize_without_endmarker(code)) - except EndMarkerReached: - return Stack(p.pgen_parser.stack) - raise SystemError("This really shouldn't happen. There's a bug in Jedi.") - - -class Stack(list): - def get_node_names(self, grammar): - for dfa, state, (node_number, nodes) in self: - yield grammar.number2symbol[node_number] - - def get_nodes(self): - for dfa, state, (node_number, nodes) in self: - for node in nodes: - yield node - - -def get_possible_completion_types(pgen_grammar, stack): - def add_results(label_index): - try: - grammar_labels.append(inversed_tokens[label_index]) - except KeyError: - try: - keywords.append(inversed_keywords[label_index]) - except KeyError: - t, v = pgen_grammar.labels[label_index] - assert t >= 256 - # See if it's a symbol and if we're in its first set - inversed_keywords - itsdfa = pgen_grammar.dfas[t] - itsstates, itsfirst = itsdfa - for first_label_index in itsfirst.keys(): - add_results(first_label_index) - - inversed_keywords = dict((v, k) for k, v in pgen_grammar.keywords.items()) - inversed_tokens = dict((v, k) for k, v in pgen_grammar.tokens.items()) - - keywords = [] - grammar_labels = [] - - def scan_stack(index): - dfa, state, node = stack[index] - states, first = dfa - arcs = states[state] - - for label_index, new_state in arcs: - if label_index == 0: - # An accepting state, check the stack below. - scan_stack(index - 1) - else: - add_results(label_index) - - scan_stack(-1) - - return keywords, grammar_labels - - -def evaluate_goto_definition(evaluator, context, leaf): - if leaf.type == 'name': - # In case of a name we can just use goto_definition which does all the - # magic itself. - return evaluator.goto_definitions(context, leaf) - - parent = leaf.parent - if parent.type == 'atom': - return context.eval_node(leaf.parent) - elif parent.type == 'trailer': - return evaluate_call_of_leaf(context, leaf) - elif isinstance(leaf, tree.Literal): - return eval_atom(context, leaf) - return [] - - -CallSignatureDetails = namedtuple( - 'CallSignatureDetails', - ['bracket_leaf', 'call_index', 'keyword_name_str'] -) - - -def _get_index_and_key(nodes, position): - """ - Returns the amount of commas and the keyword argument string. - """ - nodes_before = [c for c in nodes if c.start_pos < position] - if nodes_before[-1].type == 'arglist': - nodes_before = [c for c in nodes_before[-1].children if c.start_pos < position] - - key_str = None - - if nodes_before: - last = nodes_before[-1] - if last.type == 'argument' and last.children[1].end_pos <= position: - # Checked if the argument - key_str = last.children[0].value - elif last == '=': - key_str = nodes_before[-2].value - - return nodes_before.count(','), key_str - - -def _get_call_signature_details_from_error_node(node, position): - for index, element in reversed(list(enumerate(node.children))): - # `index > 0` means that it's a trailer and not an atom. - if element == '(' and element.end_pos <= position and index > 0: - # It's an error node, we don't want to match too much, just - # until the parentheses is enough. - children = node.children[index:] - name = element.get_previous_leaf() - if name is None: - continue - if name.type == 'name' or name.parent.type in ('trailer', 'atom'): - return CallSignatureDetails( - element, - *_get_index_and_key(children, position) - ) - - -def get_call_signature_details(module, position): - leaf = module.get_leaf_for_position(position, include_prefixes=True) - if leaf.start_pos >= position: - # Whitespace / comments after the leaf count towards the previous leaf. - leaf = leaf.get_previous_leaf() - if leaf is None: - return None - - if leaf == ')': - if leaf.end_pos == position: - leaf = leaf.get_next_leaf() - - # Now that we know where we are in the syntax tree, we start to look at - # parents for possible function definitions. - node = leaf.parent - while node is not None: - if node.type in ('funcdef', 'classdef'): - # Don't show call signatures if there's stuff before it that just - # makes it feel strange to have a call signature. - return None - - for n in node.children[::-1]: - if n.start_pos < position and n.type == 'error_node': - result = _get_call_signature_details_from_error_node(n, position) - if result is not None: - return result - - if node.type == 'trailer' and node.children[0] == '(': - leaf = node.get_previous_leaf() - if leaf is None: - return None - return CallSignatureDetails( - node.children[0], *_get_index_and_key(node.children, position)) - - node = node.parent - - return None - - -@time_cache("call_signatures_validity") -def cache_call_signatures(evaluator, context, bracket_leaf, code_lines, user_pos): - """This function calculates the cache key.""" - index = user_pos[0] - 1 - - before_cursor = code_lines[index][:user_pos[1]] - other_lines = code_lines[bracket_leaf.start_pos[0]:index] - whole = '\n'.join(other_lines + [before_cursor]) - before_bracket = re.match(r'.*\(', whole, re.DOTALL) - - module_path = context.get_root_context().py__file__() - if module_path is None: - yield None # Don't cache! - else: - yield (module_path, before_bracket, bracket_leaf.start_pos) - yield evaluate_goto_definition( - evaluator, - context, - bracket_leaf.get_previous_leaf() - ) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/interpreter.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/interpreter.py deleted file mode 100644 index 202f345..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/interpreter.py +++ /dev/null @@ -1,47 +0,0 @@ -""" -TODO Some parts of this module are still not well documented. -""" - -from jedi.evaluate.context import ModuleContext -from jedi.evaluate import compiled -from jedi.evaluate.compiled import mixed -from jedi.evaluate.base_context import Context - - -class NamespaceObject(object): - def __init__(self, dct): - self.__dict__ = dct - - -class MixedModuleContext(Context): - resets_positions = True - type = 'mixed_module' - - def __init__(self, evaluator, tree_module, namespaces, path): - self.evaluator = evaluator - self._namespaces = namespaces - - self._namespace_objects = [NamespaceObject(n) for n in namespaces] - self._module_context = ModuleContext(evaluator, tree_module, path=path) - self.tree_node = tree_module - - def get_node(self): - return self.tree_node - - def get_filters(self, *args, **kwargs): - for filter in self._module_context.get_filters(*args, **kwargs): - yield filter - - for namespace_obj in self._namespace_objects: - compiled_object = compiled.create(self.evaluator, namespace_obj) - mixed_object = mixed.MixedObject( - self.evaluator, - parent_context=self, - compiled_object=compiled_object, - tree_context=self._module_context - ) - for filter in mixed_object.get_filters(*args, **kwargs): - yield filter - - def __getattr__(self, name): - return getattr(self._module_context, name) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/keywords.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/keywords.py deleted file mode 100644 index a1bc4e7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/keywords.py +++ /dev/null @@ -1,144 +0,0 @@ -import pydoc -import keyword - -from jedi._compatibility import is_py3, is_py35 -from jedi.evaluate.utils import ignored -from jedi.evaluate.filters import AbstractNameDefinition -from parso.python.tree import Leaf - -try: - from pydoc_data import topics as pydoc_topics -except ImportError: - # Python 2 - try: - import pydoc_topics - except ImportError: - # This is for Python 3 embeddable version, which dont have - # pydoc_data module in its file python3x.zip. - pydoc_topics = None - -if is_py3: - if is_py35: - # in python 3.5 async and await are not proper keywords, but for - # completion pursposes should as as though they are - keys = keyword.kwlist + ["async", "await"] - else: - keys = keyword.kwlist -else: - keys = keyword.kwlist + ['None', 'False', 'True'] - - -def has_inappropriate_leaf_keyword(pos, module): - relevant_errors = filter( - lambda error: error.first_pos[0] == pos[0], - module.error_statement_stacks) - - for error in relevant_errors: - if error.next_token in keys: - return True - - return False - - -def completion_names(evaluator, stmt, pos, module): - keyword_list = all_keywords(evaluator) - - if not isinstance(stmt, Leaf) or has_inappropriate_leaf_keyword(pos, module): - keyword_list = filter( - lambda keyword: not keyword.only_valid_as_leaf, - keyword_list - ) - return [keyword.name for keyword in keyword_list] - - -def all_keywords(evaluator, pos=(0, 0)): - return set([Keyword(evaluator, k, pos) for k in keys]) - - -def keyword(evaluator, string, pos=(0, 0)): - if string in keys: - return Keyword(evaluator, string, pos) - else: - return None - - -def get_operator(evaluator, string, pos): - return Keyword(evaluator, string, pos) - - -keywords_only_valid_as_leaf = ( - 'continue', - 'break', -) - - -class KeywordName(AbstractNameDefinition): - api_type = 'keyword' - - def __init__(self, evaluator, name): - self.evaluator = evaluator - self.string_name = name - self.parent_context = evaluator.BUILTINS - - def eval(self): - return set() - - def infer(self): - return [Keyword(self.evaluator, self.string_name, (0, 0))] - - -class Keyword(object): - api_type = 'keyword' - - def __init__(self, evaluator, name, pos): - self.name = KeywordName(evaluator, name) - self.start_pos = pos - self.parent = evaluator.BUILTINS - - @property - def only_valid_as_leaf(self): - return self.name.value in keywords_only_valid_as_leaf - - @property - def names(self): - """ For a `parsing.Name` like comparision """ - return [self.name] - - def py__doc__(self, include_call_signature=False): - return imitate_pydoc(self.name.string_name) - - def __repr__(self): - return '<%s: %s>' % (type(self).__name__, self.name) - - -def imitate_pydoc(string): - """ - It's not possible to get the pydoc's without starting the annoying pager - stuff. - """ - if pydoc_topics is None: - return '' - - # str needed because of possible unicode stuff in py2k (pydoc doesn't work - # with unicode strings) - string = str(string) - h = pydoc.help - with ignored(KeyError): - # try to access symbols - string = h.symbols[string] - string, _, related = string.partition(' ') - - get_target = lambda s: h.topics.get(s, h.keywords.get(s)) - while isinstance(string, str): - string = get_target(string) - - try: - # is a tuple now - label, related = string - except TypeError: - return '' - - try: - return pydoc_topics.topics[label].strip() if pydoc_topics else '' - except KeyError: - return '' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/replstartup.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/replstartup.py deleted file mode 100644 index 5bfcc8c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/api/replstartup.py +++ /dev/null @@ -1,27 +0,0 @@ -""" -To use Jedi completion in Python interpreter, add the following in your shell -setup (e.g., ``.bashrc``):: - - export PYTHONSTARTUP="$(python -m jedi repl)" - -Then you will be able to use Jedi completer in your Python interpreter:: - - $ python - Python 2.7.2+ (default, Jul 20 2012, 22:15:08) - [GCC 4.6.1] on linux2 - Type "help", "copyright", "credits" or "license" for more information. - >>> import os - >>> os.path.join().split().in # doctest: +SKIP - os.path.join().split().index os.path.join().split().insert - -""" -import jedi.utils -from jedi import __version__ as __jedi_version__ - -print('REPL completion using Jedi %s' % __jedi_version__) -jedi.utils.setup_readline() - -del jedi - -# Note: try not to do many things here, as it will contaminate global -# namespace of the interpreter. diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/cache.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/cache.py deleted file mode 100644 index 01138e7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/cache.py +++ /dev/null @@ -1,121 +0,0 @@ -""" -This caching is very important for speed and memory optimizations. There's -nothing really spectacular, just some decorators. The following cache types are -available: - -- ``time_cache`` can be used to cache something for just a limited time span, - which can be useful if there's user interaction and the user cannot react - faster than a certain time. - -This module is one of the reasons why |jedi| is not thread-safe. As you can see -there are global variables, which are holding the cache information. Some of -these variables are being cleaned after every API usage. -""" -import time - -from jedi import settings -from parso.cache import parser_cache - -_time_caches = {} - - -def underscore_memoization(func): - """ - Decorator for methods:: - - class A(object): - def x(self): - if self._x: - self._x = 10 - return self._x - - Becomes:: - - class A(object): - @underscore_memoization - def x(self): - return 10 - - A now has an attribute ``_x`` written by this decorator. - """ - name = '_' + func.__name__ - - def wrapper(self): - try: - return getattr(self, name) - except AttributeError: - result = func(self) - setattr(self, name, result) - return result - - return wrapper - - -def clear_time_caches(delete_all=False): - """ Jedi caches many things, that should be completed after each completion - finishes. - - :param delete_all: Deletes also the cache that is normally not deleted, - like parser cache, which is important for faster parsing. - """ - global _time_caches - - if delete_all: - for cache in _time_caches.values(): - cache.clear() - parser_cache.clear() - else: - # normally just kill the expired entries, not all - for tc in _time_caches.values(): - # check time_cache for expired entries - for key, (t, value) in list(tc.items()): - if t < time.time(): - # delete expired entries - del tc[key] - - -def time_cache(time_add_setting): - """ - This decorator works as follows: Call it with a setting and after that - use the function with a callable that returns the key. - But: This function is only called if the key is not available. After a - certain amount of time (`time_add_setting`) the cache is invalid. - - If the given key is None, the function will not be cached. - """ - def _temp(key_func): - dct = {} - _time_caches[time_add_setting] = dct - - def wrapper(*args, **kwargs): - generator = key_func(*args, **kwargs) - key = next(generator) - try: - expiry, value = dct[key] - if expiry > time.time(): - return value - except KeyError: - pass - - value = next(generator) - time_add = getattr(settings, time_add_setting) - if key is not None: - dct[key] = time.time() + time_add, value - return value - return wrapper - return _temp - - -def memoize_method(method): - """A normal memoize function.""" - def wrapper(self, *args, **kwargs): - cache_dict = self.__dict__.setdefault('_memoize_method_dct', {}) - dct = cache_dict.setdefault(method, {}) - key = (args, frozenset(kwargs.items())) - try: - return dct[key] - except KeyError: - result = method(self, *args, **kwargs) - dct[key] = result - return result - return wrapper diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/common/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/common/__init__.py deleted file mode 100644 index 702a5e6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/common/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from jedi.common.context import BaseContextSet, BaseContext diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/common/context.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/common/context.py deleted file mode 100644 index dfcf5a9..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/common/context.py +++ /dev/null @@ -1,67 +0,0 @@ -class BaseContext(object): - def __init__(self, evaluator, parent_context=None): - self.evaluator = evaluator - self.parent_context = parent_context - - def get_root_context(self): - context = self - while True: - if context.parent_context is None: - return context - context = context.parent_context - - -class BaseContextSet(object): - def __init__(self, *args): - self._set = set(args) - - @classmethod - def from_iterable(cls, iterable): - return cls.from_set(set(iterable)) - - @classmethod - def from_set(cls, set_): - self = cls() - self._set = set_ - return self - - @classmethod - def from_sets(cls, sets): - """ - Used to work with an iterable of set. - """ - aggregated = set() - sets = list(sets) - for set_ in sets: - if isinstance(set_, BaseContextSet): - aggregated |= set_._set - else: - aggregated |= set_ - return cls.from_set(aggregated) - - def __or__(self, other): - return type(self).from_set(self._set | other._set) - - def __iter__(self): - for element in self._set: - yield element - - def __bool__(self): - return bool(self._set) - - def __len__(self): - return len(self._set) - - def __repr__(self): - return '%s(%s)' % (self.__class__.__name__, ', '.join(str(s) for s in self._set)) - - def filter(self, filter_func): - return type(self).from_iterable(filter(filter_func, self._set)) - - def __getattr__(self, name): - def mapper(*args, **kwargs): - return type(self).from_sets( - getattr(context, name)(*args, **kwargs) - for context in self._set - ) - return mapper diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/debug.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/debug.py deleted file mode 100644 index 8caf1ac..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/debug.py +++ /dev/null @@ -1,128 +0,0 @@ -from jedi._compatibility import encoding, is_py3, u -import os -import time - -def _lazy_colorama_init(): - """ - Lazily init colorama if necessary, not to screw up stdout is debug not - enabled. - - This version of the function does nothing. - """ - pass - -_inited=False - -try: - if os.name == 'nt': - # Does not work on Windows, as pyreadline and colorama interfere - raise ImportError - else: - # Use colorama for nicer console output. - from colorama import Fore, init - from colorama import initialise - def _lazy_colorama_init(): - """ - Lazily init colorama if necessary, not to screw up stdout is - debug not enabled. - - This version of the function does init colorama. - """ - global _inited - if not _inited: - # pytest resets the stream at the end - causes troubles. Since - # after every output the stream is reset automatically we don't - # need this. - initialise.atexit_done = True - try: - init() - except Exception: - # Colorama fails with initializing under vim and is buggy in - # version 0.3.6. - pass - _inited = True - -except ImportError: - class Fore(object): - RED = '' - GREEN = '' - YELLOW = '' - MAGENTA = '' - RESET = '' - -NOTICE = object() -WARNING = object() -SPEED = object() - -enable_speed = False -enable_warning = False -enable_notice = False - -# callback, interface: level, str -debug_function = None -_debug_indent = 0 -_start_time = time.time() - - -def reset_time(): - global _start_time, _debug_indent - _start_time = time.time() - _debug_indent = 0 - - -def increase_indent(func): - """Decorator for makin """ - def wrapper(*args, **kwargs): - global _debug_indent - _debug_indent += 1 - try: - return func(*args, **kwargs) - finally: - _debug_indent -= 1 - return wrapper - - -def dbg(message, *args, **kwargs): - """ Looks at the stack, to see if a debug message should be printed. """ - # Python 2 compatibility, because it doesn't understand default args - color = kwargs.pop('color', 'GREEN') - assert color - - if debug_function and enable_notice: - i = ' ' * _debug_indent - _lazy_colorama_init() - debug_function(color, i + 'dbg: ' + message % tuple(u(repr(a)) for a in args)) - - -def warning(message, *args, **kwargs): - format = kwargs.pop('format', True) - assert not kwargs - - if debug_function and enable_warning: - i = ' ' * _debug_indent - if format: - message = message % tuple(u(repr(a)) for a in args) - debug_function('RED', i + 'warning: ' + message) - - -def speed(name): - if debug_function and enable_speed: - now = time.time() - i = ' ' * _debug_indent - debug_function('YELLOW', i + 'speed: ' + '%s %s' % (name, now - _start_time)) - - -def print_to_stdout(color, str_out): - """ - The default debug function that prints to standard out. - - :param str color: A string that is an attribute of ``colorama.Fore``. - """ - col = getattr(Fore, color) - _lazy_colorama_init() - if not is_py3: - str_out = str_out.encode(encoding, 'replace') - print(col + str_out + Fore.RESET) - - -# debug_function = print_to_stdout diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/__init__.py deleted file mode 100644 index 2046107..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/__init__.py +++ /dev/null @@ -1,359 +0,0 @@ -""" -Evaluation of Python code in |jedi| is based on three assumptions: - -* The code uses as least side effects as possible. Jedi understands certain - list/tuple/set modifications, but there's no guarantee that Jedi detects - everything (list.append in different modules for example). -* No magic is being used: - - - metaclasses - - ``setattr()`` / ``__import__()`` - - writing to ``globals()``, ``locals()``, ``object.__dict__`` -* The programmer is not a total dick, e.g. like `this - `_ :-) - -The actual algorithm is based on a principle called lazy evaluation. That -said, the typical entry point for static analysis is calling -``eval_expr_stmt``. There's separate logic for autocompletion in the API, the -evaluator is all about evaluating an expression. - -TODO this paragraph is not what jedi does anymore. - -Now you need to understand what follows after ``eval_expr_stmt``. Let's -make an example:: - - import datetime - datetime.date.toda# <-- cursor here - -First of all, this module doesn't care about completion. It really just cares -about ``datetime.date``. At the end of the procedure ``eval_expr_stmt`` will -return the ``date`` class. - -To *visualize* this (simplified): - -- ``Evaluator.eval_expr_stmt`` doesn't do much, because there's no assignment. -- ``Context.eval_node`` cares for resolving the dotted path -- ``Evaluator.find_types`` searches for global definitions of datetime, which - it finds in the definition of an import, by scanning the syntax tree. -- Using the import logic, the datetime module is found. -- Now ``find_types`` is called again by ``eval_node`` to find ``date`` - inside the datetime module. - -Now what would happen if we wanted ``datetime.date.foo.bar``? Two more -calls to ``find_types``. However the second call would be ignored, because the -first one would return nothing (there's no foo attribute in ``date``). - -What if the import would contain another ``ExprStmt`` like this:: - - from foo import bar - Date = bar.baz - -Well... You get it. Just another ``eval_expr_stmt`` recursion. It's really -easy. Python can obviously get way more complicated then this. To understand -tuple assignments, list comprehensions and everything else, a lot more code had -to be written. - -Jedi has been tested very well, so you can just start modifying code. It's best -to write your own test first for your "new" feature. Don't be scared of -breaking stuff. As long as the tests pass, you're most likely to be fine. - -I need to mention now that lazy evaluation is really good because it -only *evaluates* what needs to be *evaluated*. All the statements and modules -that are not used are just being ignored. -""" - -import sys - -from parso.python import tree -import parso - -from jedi import debug -from jedi import parser_utils -from jedi.evaluate.utils import unite -from jedi.evaluate import imports -from jedi.evaluate import recursion -from jedi.evaluate.cache import evaluator_function_cache -from jedi.evaluate import compiled -from jedi.evaluate import helpers -from jedi.evaluate.filters import TreeNameDefinition, ParamName -from jedi.evaluate.base_context import ContextualizedName, ContextualizedNode, \ - ContextSet, NO_CONTEXTS, iterate_contexts -from jedi.evaluate.context import ClassContext, FunctionContext, \ - AnonymousInstance, BoundMethod -from jedi.evaluate.context.iterable import CompForContext -from jedi.evaluate.syntax_tree import eval_trailer, eval_expr_stmt, \ - eval_node, check_tuple_assignments - - -class Evaluator(object): - def __init__(self, grammar, project): - self.grammar = grammar - self.latest_grammar = parso.load_grammar(version='3.6') - self.memoize_cache = {} # for memoize decorators - # To memorize modules -> equals `sys.modules`. - self.modules = {} # like `sys.modules`. - self.compiled_cache = {} # see `evaluate.compiled.create()` - self.inferred_element_counts = {} - self.mixed_cache = {} # see `evaluate.compiled.mixed._create()` - self.analysis = [] - self.dynamic_params_depth = 0 - self.is_analysis = False - self.python_version = sys.version_info[:2] - self.project = project - project.add_evaluator(self) - - self.reset_recursion_limitations() - - # Constants - self.BUILTINS = compiled.get_special_object(self, 'BUILTINS') - - def reset_recursion_limitations(self): - self.recursion_detector = recursion.RecursionDetector() - self.execution_recursion_detector = recursion.ExecutionRecursionDetector(self) - - def eval_element(self, context, element): - if isinstance(context, CompForContext): - return eval_node(context, element) - - if_stmt = element - while if_stmt is not None: - if_stmt = if_stmt.parent - if if_stmt.type in ('if_stmt', 'for_stmt'): - break - if parser_utils.is_scope(if_stmt): - if_stmt = None - break - predefined_if_name_dict = context.predefined_names.get(if_stmt) - if predefined_if_name_dict is None and if_stmt and if_stmt.type == 'if_stmt': - if_stmt_test = if_stmt.children[1] - name_dicts = [{}] - # If we already did a check, we don't want to do it again -> If - # context.predefined_names is filled, we stop. - # We don't want to check the if stmt itself, it's just about - # the content. - if element.start_pos > if_stmt_test.end_pos: - # Now we need to check if the names in the if_stmt match the - # names in the suite. - if_names = helpers.get_names_of_node(if_stmt_test) - element_names = helpers.get_names_of_node(element) - str_element_names = [e.value for e in element_names] - if any(i.value in str_element_names for i in if_names): - for if_name in if_names: - definitions = self.goto_definitions(context, if_name) - # Every name that has multiple different definitions - # causes the complexity to rise. The complexity should - # never fall below 1. - if len(definitions) > 1: - if len(name_dicts) * len(definitions) > 16: - debug.dbg('Too many options for if branch evaluation %s.', if_stmt) - # There's only a certain amount of branches - # Jedi can evaluate, otherwise it will take to - # long. - name_dicts = [{}] - break - - original_name_dicts = list(name_dicts) - name_dicts = [] - for definition in definitions: - new_name_dicts = list(original_name_dicts) - for i, name_dict in enumerate(new_name_dicts): - new_name_dicts[i] = name_dict.copy() - new_name_dicts[i][if_name.value] = ContextSet(definition) - - name_dicts += new_name_dicts - else: - for name_dict in name_dicts: - name_dict[if_name.value] = definitions - if len(name_dicts) > 1: - result = ContextSet() - for name_dict in name_dicts: - with helpers.predefine_names(context, if_stmt, name_dict): - result |= eval_node(context, element) - return result - else: - return self._eval_element_if_evaluated(context, element) - else: - if predefined_if_name_dict: - return eval_node(context, element) - else: - return self._eval_element_if_evaluated(context, element) - - def _eval_element_if_evaluated(self, context, element): - """ - TODO This function is temporary: Merge with eval_element. - """ - parent = element - while parent is not None: - parent = parent.parent - predefined_if_name_dict = context.predefined_names.get(parent) - if predefined_if_name_dict is not None: - return eval_node(context, element) - return self._eval_element_cached(context, element) - - @evaluator_function_cache(default=NO_CONTEXTS) - def _eval_element_cached(self, context, element): - return eval_node(context, element) - - def goto_definitions(self, context, name): - def_ = name.get_definition(import_name_always=True) - if def_ is not None: - type_ = def_.type - if type_ == 'classdef': - return [ClassContext(self, context, name.parent)] - elif type_ == 'funcdef': - return [FunctionContext(self, context, name.parent)] - - if type_ == 'expr_stmt': - is_simple_name = name.parent.type not in ('power', 'trailer') - if is_simple_name: - return eval_expr_stmt(context, def_, name) - if type_ == 'for_stmt': - container_types = context.eval_node(def_.children[3]) - cn = ContextualizedNode(context, def_.children[3]) - for_types = iterate_contexts(container_types, cn) - c_node = ContextualizedName(context, name) - return check_tuple_assignments(self, c_node, for_types) - if type_ in ('import_from', 'import_name'): - return imports.infer_import(context, name) - - return helpers.evaluate_call_of_leaf(context, name) - - def goto(self, context, name): - definition = name.get_definition(import_name_always=True) - if definition is not None: - type_ = definition.type - if type_ == 'expr_stmt': - # Only take the parent, because if it's more complicated than just - # a name it's something you can "goto" again. - is_simple_name = name.parent.type not in ('power', 'trailer') - if is_simple_name: - return [TreeNameDefinition(context, name)] - elif type_ == 'param': - return [ParamName(context, name)] - elif type_ in ('funcdef', 'classdef'): - return [TreeNameDefinition(context, name)] - elif type_ in ('import_from', 'import_name'): - module_names = imports.infer_import(context, name, is_goto=True) - return module_names - - par = name.parent - node_type = par.type - if node_type == 'argument' and par.children[1] == '=' and par.children[0] == name: - # Named param goto. - trailer = par.parent - if trailer.type == 'arglist': - trailer = trailer.parent - if trailer.type != 'classdef': - if trailer.type == 'decorator': - context_set = context.eval_node(trailer.children[1]) - else: - i = trailer.parent.children.index(trailer) - to_evaluate = trailer.parent.children[:i] - if to_evaluate[0] == 'await': - to_evaluate.pop(0) - context_set = context.eval_node(to_evaluate[0]) - for trailer in to_evaluate[1:]: - context_set = eval_trailer(context, context_set, trailer) - param_names = [] - for context in context_set: - try: - get_param_names = context.get_param_names - except AttributeError: - pass - else: - for param_name in get_param_names(): - if param_name.string_name == name.value: - param_names.append(param_name) - return param_names - elif node_type == 'dotted_name': # Is a decorator. - index = par.children.index(name) - if index > 0: - new_dotted = helpers.deep_ast_copy(par) - new_dotted.children[index - 1:] = [] - values = context.eval_node(new_dotted) - return unite( - value.py__getattribute__(name, name_context=context, is_goto=True) - for value in values - ) - - if node_type == 'trailer' and par.children[0] == '.': - values = helpers.evaluate_call_of_leaf(context, name, cut_own_trailer=True) - return unite( - value.py__getattribute__(name, name_context=context, is_goto=True) - for value in values - ) - else: - stmt = tree.search_ancestor( - name, 'expr_stmt', 'lambdef' - ) or name - if stmt.type == 'lambdef': - stmt = name - return context.py__getattribute__( - name, - position=stmt.start_pos, - search_global=True, is_goto=True - ) - - def create_context(self, base_context, node, node_is_context=False, node_is_object=False): - def parent_scope(node): - while True: - node = node.parent - - if parser_utils.is_scope(node): - return node - elif node.type in ('argument', 'testlist_comp'): - if node.children[1].type == 'comp_for': - return node.children[1] - elif node.type == 'dictorsetmaker': - for n in node.children[1:4]: - # In dictionaries it can be pretty much anything. - if n.type == 'comp_for': - return n - - def from_scope_node(scope_node, child_is_funcdef=None, is_nested=True, node_is_object=False): - if scope_node == base_node: - return base_context - - is_funcdef = scope_node.type in ('funcdef', 'lambdef') - parent_scope = parser_utils.get_parent_scope(scope_node) - parent_context = from_scope_node(parent_scope, child_is_funcdef=is_funcdef) - - if is_funcdef: - if isinstance(parent_context, AnonymousInstance): - func = BoundMethod( - self, parent_context, parent_context.class_context, - parent_context.parent_context, scope_node - ) - else: - func = FunctionContext( - self, - parent_context, - scope_node - ) - if is_nested and not node_is_object: - return func.get_function_execution() - return func - elif scope_node.type == 'classdef': - class_context = ClassContext(self, parent_context, scope_node) - if child_is_funcdef: - # anonymous instance - return AnonymousInstance(self, parent_context, class_context) - else: - return class_context - elif scope_node.type == 'comp_for': - if node.start_pos >= scope_node.children[-1].start_pos: - return parent_context - return CompForContext.from_comp_for(parent_context, scope_node) - raise Exception("There's a scope that was not managed.") - - base_node = base_context.tree_node - - if node_is_context and parser_utils.is_scope(node): - scope_node = node - else: - if node.parent.type in ('funcdef', 'classdef') and node.parent.name == node: - # When we're on class/function names/leafs that define the - # object itself and not its contents. - node = node.parent - scope_node = parent_scope(node) - return from_scope_node(scope_node, is_nested=True, node_is_object=node_is_object) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/analysis.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/analysis.py deleted file mode 100644 index c825e5f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/analysis.py +++ /dev/null @@ -1,214 +0,0 @@ -""" -Module for statical analysis. -""" -from jedi import debug -from parso.python import tree -from jedi.evaluate.compiled import CompiledObject - - -CODES = { - 'attribute-error': (1, AttributeError, 'Potential AttributeError.'), - 'name-error': (2, NameError, 'Potential NameError.'), - 'import-error': (3, ImportError, 'Potential ImportError.'), - 'type-error-too-many-arguments': (4, TypeError, None), - 'type-error-too-few-arguments': (5, TypeError, None), - 'type-error-keyword-argument': (6, TypeError, None), - 'type-error-multiple-values': (7, TypeError, None), - 'type-error-star-star': (8, TypeError, None), - 'type-error-star': (9, TypeError, None), - 'type-error-operation': (10, TypeError, None), - 'type-error-not-iterable': (11, TypeError, None), - 'type-error-isinstance': (12, TypeError, None), - 'type-error-not-subscriptable': (13, TypeError, None), - 'value-error-too-many-values': (14, ValueError, None), - 'value-error-too-few-values': (15, ValueError, None), -} - - -class Error(object): - def __init__(self, name, module_path, start_pos, message=None): - self.path = module_path - self._start_pos = start_pos - self.name = name - if message is None: - message = CODES[self.name][2] - self.message = message - - @property - def line(self): - return self._start_pos[0] - - @property - def column(self): - return self._start_pos[1] - - @property - def code(self): - # The class name start - first = self.__class__.__name__[0] - return first + str(CODES[self.name][0]) - - def __unicode__(self): - return '%s:%s:%s: %s %s' % (self.path, self.line, self.column, - self.code, self.message) - - def __str__(self): - return self.__unicode__() - - def __eq__(self, other): - return (self.path == other.path and self.name == other.name and - self._start_pos == other._start_pos) - - def __ne__(self, other): - return not self.__eq__(other) - - def __hash__(self): - return hash((self.path, self._start_pos, self.name)) - - def __repr__(self): - return '<%s %s: %s@%s,%s>' % (self.__class__.__name__, - self.name, self.path, - self._start_pos[0], self._start_pos[1]) - - -class Warning(Error): - pass - - -def add(node_context, error_name, node, message=None, typ=Error, payload=None): - exception = CODES[error_name][1] - if _check_for_exception_catch(node_context, node, exception, payload): - return - - # TODO this path is probably not right - module_context = node_context.get_root_context() - module_path = module_context.py__file__() - instance = typ(error_name, module_path, node.start_pos, message) - debug.warning(str(instance), format=False) - node_context.evaluator.analysis.append(instance) - - -def _check_for_setattr(instance): - """ - Check if there's any setattr method inside an instance. If so, return True. - """ - from jedi.evaluate.context import ModuleContext - module = instance.get_root_context() - if not isinstance(module, ModuleContext): - return False - - node = module.tree_node - try: - stmts = node.get_used_names()['setattr'] - except KeyError: - return False - - return any(node.start_pos < stmt.start_pos < node.end_pos - for stmt in stmts) - - -def add_attribute_error(name_context, lookup_context, name): - message = ('AttributeError: %s has no attribute %s.' % (lookup_context, name)) - from jedi.evaluate.context.instance import AbstractInstanceContext, CompiledInstanceName - # Check for __getattr__/__getattribute__ existance and issue a warning - # instead of an error, if that happens. - typ = Error - if isinstance(lookup_context, AbstractInstanceContext): - slot_names = lookup_context.get_function_slot_names('__getattr__') + \ - lookup_context.get_function_slot_names('__getattribute__') - for n in slot_names: - if isinstance(name, CompiledInstanceName) and \ - n.parent_context.obj == object: - typ = Warning - break - - if _check_for_setattr(lookup_context): - typ = Warning - - payload = lookup_context, name - add(name_context, 'attribute-error', name, message, typ, payload) - - -def _check_for_exception_catch(node_context, jedi_name, exception, payload=None): - """ - Checks if a jedi object (e.g. `Statement`) sits inside a try/catch and - doesn't count as an error (if equal to `exception`). - Also checks `hasattr` for AttributeErrors and uses the `payload` to compare - it. - Returns True if the exception was catched. - """ - def check_match(cls, exception): - try: - return isinstance(cls, CompiledObject) and issubclass(exception, cls.obj) - except TypeError: - return False - - def check_try_for_except(obj, exception): - # Only nodes in try - iterator = iter(obj.children) - for branch_type in iterator: - colon = next(iterator) - suite = next(iterator) - if branch_type == 'try' \ - and not (branch_type.start_pos < jedi_name.start_pos <= suite.end_pos): - return False - - for node in obj.get_except_clause_tests(): - if node is None: - return True # An exception block that catches everything. - else: - except_classes = node_context.eval_node(node) - for cls in except_classes: - from jedi.evaluate.context import iterable - if isinstance(cls, iterable.AbstractIterable) and \ - cls.array_type == 'tuple': - # multiple exceptions - for lazy_context in cls.py__iter__(): - for typ in lazy_context.infer(): - if check_match(typ, exception): - return True - else: - if check_match(cls, exception): - return True - - def check_hasattr(node, suite): - try: - assert suite.start_pos <= jedi_name.start_pos < suite.end_pos - assert node.type in ('power', 'atom_expr') - base = node.children[0] - assert base.type == 'name' and base.value == 'hasattr' - trailer = node.children[1] - assert trailer.type == 'trailer' - arglist = trailer.children[1] - assert arglist.type == 'arglist' - from jedi.evaluate.arguments import TreeArguments - args = list(TreeArguments(node_context.evaluator, node_context, arglist).unpack()) - # Arguments should be very simple - assert len(args) == 2 - - # Check name - key, lazy_context = args[1] - names = list(lazy_context.infer()) - assert len(names) == 1 and isinstance(names[0], CompiledObject) - assert names[0].obj == payload[1].value - - # Check objects - key, lazy_context = args[0] - objects = lazy_context.infer() - return payload[0] in objects - except AssertionError: - return False - - obj = jedi_name - while obj is not None and not isinstance(obj, (tree.Function, tree.Class)): - if isinstance(obj, tree.Flow): - # try/except catch check - if obj.type == 'try_stmt' and check_try_for_except(obj, exception): - return True - # hasattr check - if exception == AttributeError and obj.type in ('if_stmt', 'while_stmt'): - if check_hasattr(obj.children[1], obj.children[3]): - return True - obj = obj.parent - - return False diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/arguments.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/arguments.py deleted file mode 100644 index 32b9238..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/arguments.py +++ /dev/null @@ -1,245 +0,0 @@ -from parso.python import tree - -from jedi._compatibility import zip_longest -from jedi import debug -from jedi.evaluate import analysis -from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \ - LazyTreeContext, get_merged_lazy_context -from jedi.evaluate.filters import ParamName -from jedi.evaluate.base_context import NO_CONTEXTS -from jedi.evaluate.context import iterable -from jedi.evaluate.param import get_params, ExecutedParam - -def try_iter_content(types, depth=0): - """Helper method for static analysis.""" - if depth > 10: - # It's possible that a loop has references on itself (especially with - # CompiledObject). Therefore don't loop infinitely. - return - - for typ in types: - try: - f = typ.py__iter__ - except AttributeError: - pass - else: - for lazy_context in f(): - try_iter_content(lazy_context.infer(), depth + 1) - - -class AbstractArguments(object): - context = None - - def eval_argument_clinic(self, parameters): - """Uses a list with argument clinic information (see PEP 436).""" - iterator = self.unpack() - for i, (name, optional, allow_kwargs) in enumerate(parameters): - key, argument = next(iterator, (None, None)) - if key is not None: - raise NotImplementedError - if argument is None and not optional: - debug.warning('TypeError: %s expected at least %s arguments, got %s', - name, len(parameters), i) - raise ValueError - values = NO_CONTEXTS if argument is None else argument.infer() - - if not values and not optional: - # For the stdlib we always want values. If we don't get them, - # that's ok, maybe something is too hard to resolve, however, - # we will not proceed with the evaluation of that function. - debug.warning('argument_clinic "%s" not resolvable.', name) - raise ValueError - yield values - - def eval_all(self, funcdef=None): - """ - Evaluates all arguments as a support for static analysis - (normally Jedi). - """ - for key, lazy_context in self.unpack(): - types = lazy_context.infer() - try_iter_content(types) - - def get_calling_nodes(self): - raise NotImplementedError - - def unpack(self, funcdef=None): - raise NotImplementedError - - def get_params(self, execution_context): - return get_params(execution_context, self) - - -class AnonymousArguments(AbstractArguments): - def get_params(self, execution_context): - from jedi.evaluate.dynamic import search_params - return search_params( - execution_context.evaluator, - execution_context, - execution_context.tree_node - ) - - -class TreeArguments(AbstractArguments): - def __init__(self, evaluator, context, argument_node, trailer=None): - """ - The argument_node is either a parser node or a list of evaluated - objects. Those evaluated objects may be lists of evaluated objects - themselves (one list for the first argument, one for the second, etc). - - :param argument_node: May be an argument_node or a list of nodes. - """ - self.argument_node = argument_node - self.context = context - self._evaluator = evaluator - self.trailer = trailer # Can be None, e.g. in a class definition. - - def _split(self): - if isinstance(self.argument_node, (tuple, list)): - for el in self.argument_node: - yield 0, el - else: - if not (self.argument_node.type == 'arglist' or ( - # in python 3.5 **arg is an argument, not arglist - (self.argument_node.type == 'argument') and - self.argument_node.children[0] in ('*', '**'))): - yield 0, self.argument_node - return - - iterator = iter(self.argument_node.children) - for child in iterator: - if child == ',': - continue - elif child in ('*', '**'): - yield len(child.value), next(iterator) - elif child.type == 'argument' and \ - child.children[0] in ('*', '**'): - assert len(child.children) == 2 - yield len(child.children[0].value), child.children[1] - else: - yield 0, child - - def unpack(self, funcdef=None): - named_args = [] - for star_count, el in self._split(): - if star_count == 1: - arrays = self.context.eval_node(el) - iterators = [_iterate_star_args(self.context, a, el, funcdef) - for a in arrays] - iterators = list(iterators) - for values in list(zip_longest(*iterators)): - # TODO zip_longest yields None, that means this would raise - # an exception? - yield None, get_merged_lazy_context( - [v for v in values if v is not None] - ) - elif star_count == 2: - arrays = self._evaluator.eval_element(self.context, el) - for dct in arrays: - for key, values in _star_star_dict(self.context, dct, el, funcdef): - yield key, values - else: - if el.type == 'argument': - c = el.children - if len(c) == 3: # Keyword argument. - named_args.append((c[0].value, LazyTreeContext(self.context, c[2]),)) - else: # Generator comprehension. - # Include the brackets with the parent. - comp = iterable.GeneratorComprehension( - self._evaluator, self.context, self.argument_node.parent) - yield None, LazyKnownContext(comp) - else: - yield None, LazyTreeContext(self.context, el) - - # Reordering var_args is necessary, because star args sometimes appear - # after named argument, but in the actual order it's prepended. - for named_arg in named_args: - yield named_arg - - def as_tree_tuple_objects(self): - for star_count, argument in self._split(): - if argument.type == 'argument': - argument, default = argument.children[::2] - else: - default = None - yield argument, default, star_count - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self.argument_node) - - def get_calling_nodes(self): - from jedi.evaluate.dynamic import MergedExecutedParams - old_arguments_list = [] - arguments = self - - while arguments not in old_arguments_list: - if not isinstance(arguments, TreeArguments): - break - - old_arguments_list.append(arguments) - for name, default, star_count in reversed(list(arguments.as_tree_tuple_objects())): - if not star_count or not isinstance(name, tree.Name): - continue - - names = self._evaluator.goto(arguments.context, name) - if len(names) != 1: - break - if not isinstance(names[0], ParamName): - break - param = names[0].get_param() - if isinstance(param, MergedExecutedParams): - # For dynamic searches we don't even want to see errors. - return [] - if not isinstance(param, ExecutedParam): - break - if param.var_args is None: - break - arguments = param.var_args - break - - return [arguments.argument_node or arguments.trailer] - - -class ValuesArguments(AbstractArguments): - def __init__(self, values_list): - self._values_list = values_list - - def unpack(self, funcdef=None): - for values in self._values_list: - yield None, LazyKnownContexts(values) - - def get_calling_nodes(self): - return [] - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self._values_list) - - -def _iterate_star_args(context, array, input_node, funcdef=None): - try: - iter_ = array.py__iter__ - except AttributeError: - if funcdef is not None: - # TODO this funcdef should not be needed. - m = "TypeError: %s() argument after * must be a sequence, not %s" \ - % (funcdef.name.value, array) - analysis.add(context, 'type-error-star', input_node, message=m) - else: - for lazy_context in iter_(): - yield lazy_context - - -def _star_star_dict(context, array, input_node, funcdef): - from jedi.evaluate.context.instance import CompiledInstance - if isinstance(array, CompiledInstance) and array.name.string_name == 'dict': - # For now ignore this case. In the future add proper iterators and just - # make one call without crazy isinstance checks. - return {} - elif isinstance(array, iterable.AbstractIterable) and array.array_type == 'dict': - return array.exact_key_items() - else: - if funcdef is not None: - m = "TypeError: %s argument after ** must be a mapping, not %s" \ - % (funcdef.name.value, array) - analysis.add(context, 'type-error-star-star', input_node, message=m) - return {} diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/base_context.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/base_context.py deleted file mode 100644 index 693a99a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/base_context.py +++ /dev/null @@ -1,260 +0,0 @@ -from parso.python.tree import ExprStmt, CompFor - -from jedi import debug -from jedi._compatibility import Python3Method, zip_longest, unicode -from jedi.parser_utils import clean_scope_docstring, get_doc_with_call_signature -from jedi.common import BaseContextSet, BaseContext - - -class Context(BaseContext): - """ - Should be defined, otherwise the API returns empty types. - """ - - predefined_names = {} - tree_node = None - """ - To be defined by subclasses. - """ - - @property - def api_type(self): - # By default just lower name of the class. Can and should be - # overwritten. - return self.__class__.__name__.lower() - - @debug.increase_indent - def execute(self, arguments): - """ - In contrast to py__call__ this function is always available. - - `hasattr(x, py__call__)` can also be checked to see if a context is - executable. - """ - if self.evaluator.is_analysis: - arguments.eval_all() - - debug.dbg('execute: %s %s', self, arguments) - from jedi.evaluate import stdlib - try: - # Some stdlib functions like super(), namedtuple(), etc. have been - # hard-coded in Jedi to support them. - return stdlib.execute(self.evaluator, self, arguments) - except stdlib.NotInStdLib: - pass - - try: - func = self.py__call__ - except AttributeError: - debug.warning("no execution possible %s", self) - return NO_CONTEXTS - else: - context_set = func(arguments) - debug.dbg('execute result: %s in %s', context_set, self) - return context_set - - return self.evaluator.execute(self, arguments) - - def execute_evaluated(self, *value_list): - """ - Execute a function with already executed arguments. - """ - from jedi.evaluate.arguments import ValuesArguments - arguments = ValuesArguments([ContextSet(value) for value in value_list]) - return self.execute(arguments) - - def iterate(self, contextualized_node=None): - debug.dbg('iterate') - try: - iter_method = self.py__iter__ - except AttributeError: - if contextualized_node is not None: - from jedi.evaluate import analysis - analysis.add( - contextualized_node.context, - 'type-error-not-iterable', - contextualized_node.node, - message="TypeError: '%s' object is not iterable" % self) - return iter([]) - else: - return iter_method() - - def get_item(self, index_contexts, contextualized_node): - from jedi.evaluate.compiled import CompiledObject - from jedi.evaluate.context.iterable import Slice, AbstractIterable - result = ContextSet() - - for index in index_contexts: - if isinstance(index, (CompiledObject, Slice)): - index = index.obj - - if type(index) not in (float, int, str, unicode, slice, type(Ellipsis)): - # If the index is not clearly defined, we have to get all the - # possiblities. - if isinstance(self, AbstractIterable) and self.array_type == 'dict': - result |= self.dict_values() - else: - result |= iterate_contexts(ContextSet(self)) - continue - - # The actual getitem call. - try: - getitem = self.py__getitem__ - except AttributeError: - from jedi.evaluate import analysis - # TODO this context is probably not right. - analysis.add( - contextualized_node.context, - 'type-error-not-subscriptable', - contextualized_node.node, - message="TypeError: '%s' object is not subscriptable" % self - ) - else: - try: - result |= getitem(index) - except IndexError: - result |= iterate_contexts(ContextSet(self)) - except KeyError: - # Must be a dict. Lists don't raise KeyErrors. - result |= self.dict_values() - return result - - def eval_node(self, node): - return self.evaluator.eval_element(self, node) - - @Python3Method - def py__getattribute__(self, name_or_str, name_context=None, position=None, - search_global=False, is_goto=False, - analysis_errors=True): - """ - :param position: Position of the last statement -> tuple of line, column - """ - if name_context is None: - name_context = self - from jedi.evaluate import finder - f = finder.NameFinder(self.evaluator, self, name_context, name_or_str, - position, analysis_errors=analysis_errors) - filters = f.get_filters(search_global) - if is_goto: - return f.filter_name(filters) - return f.find(filters, attribute_lookup=not search_global) - - return self.evaluator.find_types( - self, name_or_str, name_context, position, search_global, is_goto, - analysis_errors) - - def create_context(self, node, node_is_context=False, node_is_object=False): - return self.evaluator.create_context(self, node, node_is_context, node_is_object) - - def is_class(self): - return False - - def py__bool__(self): - """ - Since Wrapper is a super class for classes, functions and modules, - the return value will always be true. - """ - return True - - def py__doc__(self, include_call_signature=False): - try: - self.tree_node.get_doc_node - except AttributeError: - return '' - else: - if include_call_signature: - return get_doc_with_call_signature(self.tree_node) - else: - return clean_scope_docstring(self.tree_node) - return None - - -def iterate_contexts(contexts, contextualized_node=None): - """ - Calls `iterate`, on all contexts but ignores the ordering and just returns - all contexts that the iterate functions yield. - """ - return ContextSet.from_sets( - lazy_context.infer() - for lazy_context in contexts.iterate(contextualized_node) - ) - - -class TreeContext(Context): - def __init__(self, evaluator, parent_context=None): - super(TreeContext, self).__init__(evaluator, parent_context) - self.predefined_names = {} - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self.tree_node) - - -class ContextualizedNode(object): - def __init__(self, context, node): - self.context = context - self.node = node - - def get_root_context(self): - return self.context.get_root_context() - - def infer(self): - return self.context.eval_node(self.node) - - -class ContextualizedName(ContextualizedNode): - # TODO merge with TreeNameDefinition?! - @property - def name(self): - return self.node - - def assignment_indexes(self): - """ - Returns an array of tuple(int, node) of the indexes that are used in - tuple assignments. - - For example if the name is ``y`` in the following code:: - - x, (y, z) = 2, '' - - would result in ``[(1, xyz_node), (0, yz_node)]``. - """ - indexes = [] - node = self.node.parent - compare = self.node - while node is not None: - if node.type in ('testlist', 'testlist_comp', 'testlist_star_expr', 'exprlist'): - for i, child in enumerate(node.children): - if child == compare: - indexes.insert(0, (int(i / 2), node)) - break - else: - raise LookupError("Couldn't find the assignment.") - elif isinstance(node, (ExprStmt, CompFor)): - break - - compare = node - node = node.parent - return indexes - - -class ContextSet(BaseContextSet): - def py__class__(self): - return ContextSet.from_iterable(c.py__class__() for c in self._set) - - def iterate(self, contextualized_node=None): - from jedi.evaluate.lazy_context import get_merged_lazy_context - type_iters = [c.iterate(contextualized_node) for c in self._set] - for lazy_contexts in zip_longest(*type_iters): - yield get_merged_lazy_context( - [l for l in lazy_contexts if l is not None] - ) - - -NO_CONTEXTS = ContextSet() - - -def iterator_to_context_set(func): - def wrapper(*args, **kwargs): - return ContextSet.from_iterable(func(*args, **kwargs)) - - return wrapper diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/cache.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/cache.py deleted file mode 100644 index b7c7cd7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/cache.py +++ /dev/null @@ -1,77 +0,0 @@ -""" -- the popular ``_memoize_default`` works like a typical memoize and returns the - default otherwise. -- ``CachedMetaClass`` uses ``_memoize_default`` to do the same with classes. -""" - -_NO_DEFAULT = object() - - -def _memoize_default(default=_NO_DEFAULT, evaluator_is_first_arg=False, second_arg_is_evaluator=False): - """ This is a typical memoization decorator, BUT there is one difference: - To prevent recursion it sets defaults. - - Preventing recursion is in this case the much bigger use than speed. I - don't think, that there is a big speed difference, but there are many cases - where recursion could happen (think about a = b; b = a). - """ - def func(function): - def wrapper(obj, *args, **kwargs): - # TODO These checks are kind of ugly and slow. - if evaluator_is_first_arg: - cache = obj.memoize_cache - elif second_arg_is_evaluator: - cache = args[0].memoize_cache # needed for meta classes - else: - cache = obj.evaluator.memoize_cache - - try: - memo = cache[function] - except KeyError: - memo = {} - cache[function] = memo - - key = (obj, args, frozenset(kwargs.items())) - if key in memo: - return memo[key] - else: - if default is not _NO_DEFAULT: - memo[key] = default - rv = function(obj, *args, **kwargs) - memo[key] = rv - return rv - return wrapper - - return func - - -def evaluator_function_cache(default=_NO_DEFAULT): - def decorator(func): - return _memoize_default(default=default, evaluator_is_first_arg=True)(func) - - return decorator - - -def evaluator_method_cache(default=_NO_DEFAULT): - def decorator(func): - return _memoize_default(default=default)(func) - - return decorator - - -def _memoize_meta_class(): - def decorator(call): - return _memoize_default(second_arg_is_evaluator=True)(call) - - return decorator - - -class CachedMetaClass(type): - """ - This is basically almost the same than the decorator above, it just caches - class initializations. Either you do it this way or with decorators, but - with decorators you lose class access (isinstance, etc). - """ - @_memoize_meta_class() - def __call__(self, *args, **kwargs): - return super(CachedMetaClass, self).__call__(*args, **kwargs) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/__init__.py deleted file mode 100644 index f9f2e07..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/__init__.py +++ /dev/null @@ -1,638 +0,0 @@ -""" -Imitate the parser representation. -""" -import inspect -import re -import sys -import os -import types -from functools import partial - -from jedi._compatibility import builtins as _builtins, unicode, py_version -from jedi import debug -from jedi.cache import underscore_memoization, memoize_method -from jedi.evaluate.filters import AbstractFilter, AbstractNameDefinition, \ - ContextNameMixin -from jedi.evaluate.base_context import Context, ContextSet -from jedi.evaluate.lazy_context import LazyKnownContext -from jedi.evaluate.compiled.getattr_static import getattr_static -from . import fake - - -_sep = os.path.sep -if os.path.altsep is not None: - _sep += os.path.altsep -_path_re = re.compile('(?:\.[^{0}]+|[{0}]__init__\.py)$'.format(re.escape(_sep))) -del _sep - -# Those types don't exist in typing. -MethodDescriptorType = type(str.replace) -WrapperDescriptorType = type(set.__iter__) -# `object.__subclasshook__` is an already executed descriptor. -object_class_dict = type.__dict__["__dict__"].__get__(object) -ClassMethodDescriptorType = type(object_class_dict['__subclasshook__']) - -ALLOWED_DESCRIPTOR_ACCESS = ( - types.FunctionType, - types.GetSetDescriptorType, - types.MemberDescriptorType, - MethodDescriptorType, - WrapperDescriptorType, - ClassMethodDescriptorType, - staticmethod, - classmethod, -) - -class CheckAttribute(object): - """Raises an AttributeError if the attribute X isn't available.""" - def __init__(self, func): - self.func = func - # Remove the py in front of e.g. py__call__. - self.check_name = func.__name__[2:] - - def __get__(self, instance, owner): - # This might raise an AttributeError. That's wanted. - if self.check_name == '__iter__': - # Python iterators are a bit strange, because there's no need for - # the __iter__ function as long as __getitem__ is defined (it will - # just start with __getitem__(0). This is especially true for - # Python 2 strings, where `str.__iter__` is not even defined. - try: - iter(instance.obj) - except TypeError: - raise AttributeError - else: - getattr(instance.obj, self.check_name) - return partial(self.func, instance) - - -class CompiledObject(Context): - path = None # modules have this attribute - set it to None. - used_names = lambda self: {} # To be consistent with modules. - - def __init__(self, evaluator, obj, parent_context=None, faked_class=None): - super(CompiledObject, self).__init__(evaluator, parent_context) - self.obj = obj - # This attribute will not be set for most classes, except for fakes. - self.tree_node = faked_class - - def get_root_node(self): - # To make things a bit easier with filters we add this method here. - return self.get_root_context() - - @CheckAttribute - def py__call__(self, params): - if inspect.isclass(self.obj): - from jedi.evaluate.context import CompiledInstance - return ContextSet(CompiledInstance(self.evaluator, self.parent_context, self, params)) - else: - return ContextSet.from_iterable(self._execute_function(params)) - - @CheckAttribute - def py__class__(self): - return create(self.evaluator, self.obj.__class__) - - @CheckAttribute - def py__mro__(self): - return (self,) + tuple(create(self.evaluator, cls) for cls in self.obj.__mro__[1:]) - - @CheckAttribute - def py__bases__(self): - return tuple(create(self.evaluator, cls) for cls in self.obj.__bases__) - - def py__bool__(self): - return bool(self.obj) - - def py__file__(self): - try: - return self.obj.__file__ - except AttributeError: - return None - - def is_class(self): - return inspect.isclass(self.obj) - - def py__doc__(self, include_call_signature=False): - return inspect.getdoc(self.obj) or '' - - def get_param_names(self): - obj = self.obj - try: - if py_version < 33: - raise ValueError("inspect.signature was introduced in 3.3") - if py_version == 34: - # In 3.4 inspect.signature are wrong for str and int. This has - # been fixed in 3.5. The signature of object is returned, - # because no signature was found for str. Here we imitate 3.5 - # logic and just ignore the signature if the magic methods - # don't match object. - # 3.3 doesn't even have the logic and returns nothing for str - # and classes that inherit from object. - user_def = inspect._signature_get_user_defined_method - if (inspect.isclass(obj) - and not user_def(type(obj), '__init__') - and not user_def(type(obj), '__new__') - and (obj.__init__ != object.__init__ - or obj.__new__ != object.__new__)): - raise ValueError - - signature = inspect.signature(obj) - except ValueError: # Has no signature - params_str, ret = self._parse_function_doc() - tokens = params_str.split(',') - if inspect.ismethoddescriptor(obj): - tokens.insert(0, 'self') - for p in tokens: - parts = p.strip().split('=') - yield UnresolvableParamName(self, parts[0]) - else: - for signature_param in signature.parameters.values(): - yield SignatureParamName(self, signature_param) - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, repr(self.obj)) - - @underscore_memoization - def _parse_function_doc(self): - doc = self.py__doc__() - if doc is None: - return '', '' - - return _parse_function_doc(doc) - - @property - def api_type(self): - obj = self.obj - if inspect.isclass(obj): - return 'class' - elif inspect.ismodule(obj): - return 'module' - elif inspect.isbuiltin(obj) or inspect.ismethod(obj) \ - or inspect.ismethoddescriptor(obj) or inspect.isfunction(obj): - return 'function' - # Everything else... - return 'instance' - - @property - def type(self): - """Imitate the tree.Node.type values.""" - cls = self._get_class() - if inspect.isclass(cls): - return 'classdef' - elif inspect.ismodule(cls): - return 'file_input' - elif inspect.isbuiltin(cls) or inspect.ismethod(cls) or \ - inspect.ismethoddescriptor(cls): - return 'funcdef' - - @underscore_memoization - def _cls(self): - """ - We used to limit the lookups for instantiated objects like list(), but - this is not the case anymore. Python itself - """ - # Ensures that a CompiledObject is returned that is not an instance (like list) - return self - - def _get_class(self): - if not fake.is_class_instance(self.obj) or \ - inspect.ismethoddescriptor(self.obj): # slots - return self.obj - - try: - return self.obj.__class__ - except AttributeError: - # happens with numpy.core.umath._UFUNC_API (you get it - # automatically by doing `import numpy`. - return type - - def get_filters(self, search_global=False, is_instance=False, - until_position=None, origin_scope=None): - yield self._ensure_one_filter(is_instance) - - @memoize_method - def _ensure_one_filter(self, is_instance): - """ - search_global shouldn't change the fact that there's one dict, this way - there's only one `object`. - """ - return CompiledObjectFilter(self.evaluator, self, is_instance) - - @CheckAttribute - def py__getitem__(self, index): - if type(self.obj) not in (str, list, tuple, unicode, bytes, bytearray, dict): - # Get rid of side effects, we won't call custom `__getitem__`s. - return ContextSet() - - return ContextSet(create(self.evaluator, self.obj[index])) - - @CheckAttribute - def py__iter__(self): - if type(self.obj) not in (str, list, tuple, unicode, bytes, bytearray, dict): - # Get rid of side effects, we won't call custom `__getitem__`s. - return - - for i, part in enumerate(self.obj): - if i > 20: - # Should not go crazy with large iterators - break - yield LazyKnownContext(create(self.evaluator, part)) - - def py__name__(self): - try: - return self._get_class().__name__ - except AttributeError: - return None - - @property - def name(self): - try: - name = self._get_class().__name__ - except AttributeError: - name = repr(self.obj) - return CompiledContextName(self, name) - - def _execute_function(self, params): - from jedi.evaluate import docstrings - if self.type != 'funcdef': - return - for name in self._parse_function_doc()[1].split(): - try: - bltn_obj = getattr(_builtins, name) - except AttributeError: - continue - else: - if bltn_obj is None: - # We want to evaluate everything except None. - # TODO do we? - continue - bltn_obj = create(self.evaluator, bltn_obj) - for result in bltn_obj.execute(params): - yield result - for type_ in docstrings.infer_return_types(self): - yield type_ - - def get_self_attributes(self): - return [] # Instance compatibility - - def get_imports(self): - return [] # Builtins don't have imports - - def dict_values(self): - return ContextSet.from_iterable( - create(self.evaluator, v) for v in self.obj.values() - ) - - -class CompiledName(AbstractNameDefinition): - def __init__(self, evaluator, parent_context, name): - self._evaluator = evaluator - self.parent_context = parent_context - self.string_name = name - - def __repr__(self): - try: - name = self.parent_context.name # __name__ is not defined all the time - except AttributeError: - name = None - return '<%s: (%s).%s>' % (self.__class__.__name__, name, self.string_name) - - @property - def api_type(self): - return next(iter(self.infer())).api_type - - @underscore_memoization - def infer(self): - module = self.parent_context.get_root_context() - return ContextSet(_create_from_name( - self._evaluator, module, self.parent_context, self.string_name - )) - - -class SignatureParamName(AbstractNameDefinition): - api_type = 'param' - - def __init__(self, compiled_obj, signature_param): - self.parent_context = compiled_obj.parent_context - self._signature_param = signature_param - - @property - def string_name(self): - return self._signature_param.name - - def infer(self): - p = self._signature_param - evaluator = self.parent_context.evaluator - contexts = ContextSet() - if p.default is not p.empty: - contexts = ContextSet(create(evaluator, p.default)) - if p.annotation is not p.empty: - annotation = create(evaluator, p.annotation) - contexts |= annotation.execute_evaluated() - return contexts - - -class UnresolvableParamName(AbstractNameDefinition): - api_type = 'param' - - def __init__(self, compiled_obj, name): - self.parent_context = compiled_obj.parent_context - self.string_name = name - - def infer(self): - return ContextSet() - - -class CompiledContextName(ContextNameMixin, AbstractNameDefinition): - def __init__(self, context, name): - self.string_name = name - self._context = context - self.parent_context = context.parent_context - - -class EmptyCompiledName(AbstractNameDefinition): - """ - Accessing some names will raise an exception. To avoid not having any - completions, just give Jedi the option to return this object. It infers to - nothing. - """ - def __init__(self, evaluator, name): - self.parent_context = evaluator.BUILTINS - self.string_name = name - - def infer(self): - return ContextSet() - - -class CompiledObjectFilter(AbstractFilter): - name_class = CompiledName - - def __init__(self, evaluator, compiled_object, is_instance=False): - self._evaluator = evaluator - self._compiled_object = compiled_object - self._is_instance = is_instance - - @memoize_method - def get(self, name): - name = str(name) - obj = self._compiled_object.obj - try: - attr, is_get_descriptor = getattr_static(obj, name) - except AttributeError: - return [] - else: - if is_get_descriptor \ - and not type(attr) in ALLOWED_DESCRIPTOR_ACCESS: - # In case of descriptors that have get methods we cannot return - # it's value, because that would mean code execution. - return [EmptyCompiledName(self._evaluator, name)] - if self._is_instance and name not in dir(obj): - return [] - return [self._create_name(name)] - - def values(self): - obj = self._compiled_object.obj - - names = [] - for name in dir(obj): - names += self.get(name) - - is_instance = self._is_instance or fake.is_class_instance(obj) - # ``dir`` doesn't include the type names. - if not inspect.ismodule(obj) and (obj is not type) and not is_instance: - for filter in create(self._evaluator, type).get_filters(): - names += filter.values() - return names - - def _create_name(self, name): - return self.name_class(self._evaluator, self._compiled_object, name) - - -def dotted_from_fs_path(fs_path, sys_path): - """ - Changes `/usr/lib/python3.4/email/utils.py` to `email.utils`. I.e. - compares the path with sys.path and then returns the dotted_path. If the - path is not in the sys.path, just returns None. - """ - if os.path.basename(fs_path).startswith('__init__.'): - # We are calculating the path. __init__ files are not interesting. - fs_path = os.path.dirname(fs_path) - - # prefer - # - UNIX - # /path/to/pythonX.Y/lib-dynload - # /path/to/pythonX.Y/site-packages - # - Windows - # C:\path\to\DLLs - # C:\path\to\Lib\site-packages - # over - # - UNIX - # /path/to/pythonX.Y - # - Windows - # C:\path\to\Lib - path = '' - for s in sys_path: - if (fs_path.startswith(s) and len(path) < len(s)): - path = s - - # - Window - # X:\path\to\lib-dynload/datetime.pyd => datetime - module_path = fs_path[len(path):].lstrip(os.path.sep).lstrip('/') - # - Window - # Replace like X:\path\to\something/foo/bar.py - return _path_re.sub('', module_path).replace(os.path.sep, '.').replace('/', '.') - - -def load_module(evaluator, path=None, name=None): - sys_path = list(evaluator.project.sys_path) - if path is not None: - dotted_path = dotted_from_fs_path(path, sys_path=sys_path) - else: - dotted_path = name - - temp, sys.path = sys.path, sys_path - try: - __import__(dotted_path) - except RuntimeError: - if 'PySide' in dotted_path or 'PyQt' in dotted_path: - # RuntimeError: the PyQt4.QtCore and PyQt5.QtCore modules both wrap - # the QObject class. - # See https://github.com/davidhalter/jedi/pull/483 - return None - raise - except ImportError: - # If a module is "corrupt" or not really a Python module or whatever. - debug.warning('Module %s not importable in path %s.', dotted_path, path) - return None - finally: - sys.path = temp - - # Just access the cache after import, because of #59 as well as the very - # complicated import structure of Python. - module = sys.modules[dotted_path] - - return create(evaluator, module) - - -docstr_defaults = { - 'floating point number': 'float', - 'character': 'str', - 'integer': 'int', - 'dictionary': 'dict', - 'string': 'str', -} - - -def _parse_function_doc(doc): - """ - Takes a function and returns the params and return value as a tuple. - This is nothing more than a docstring parser. - - TODO docstrings like utime(path, (atime, mtime)) and a(b [, b]) -> None - TODO docstrings like 'tuple of integers' - """ - # parse round parentheses: def func(a, (b,c)) - try: - count = 0 - start = doc.index('(') - for i, s in enumerate(doc[start:]): - if s == '(': - count += 1 - elif s == ')': - count -= 1 - if count == 0: - end = start + i - break - param_str = doc[start + 1:end] - except (ValueError, UnboundLocalError): - # ValueError for doc.index - # UnboundLocalError for undefined end in last line - debug.dbg('no brackets found - no param') - end = 0 - param_str = '' - else: - # remove square brackets, that show an optional param ( = None) - def change_options(m): - args = m.group(1).split(',') - for i, a in enumerate(args): - if a and '=' not in a: - args[i] += '=None' - return ','.join(args) - - while True: - param_str, changes = re.subn(r' ?\[([^\[\]]+)\]', - change_options, param_str) - if changes == 0: - break - param_str = param_str.replace('-', '_') # see: isinstance.__doc__ - - # parse return value - r = re.search('-[>-]* ', doc[end:end + 7]) - if r is None: - ret = '' - else: - index = end + r.end() - # get result type, which can contain newlines - pattern = re.compile(r'(,\n|[^\n-])+') - ret_str = pattern.match(doc, index).group(0).strip() - # New object -> object() - ret_str = re.sub(r'[nN]ew (.*)', r'\1()', ret_str) - - ret = docstr_defaults.get(ret_str, ret_str) - - return param_str, ret - - -def _create_from_name(evaluator, module, compiled_object, name): - obj = compiled_object.obj - faked = None - try: - faked = fake.get_faked(evaluator, module, obj, parent_context=compiled_object, name=name) - if faked.type == 'funcdef': - from jedi.evaluate.context.function import FunctionContext - return FunctionContext(evaluator, compiled_object, faked) - except fake.FakeDoesNotExist: - pass - - try: - obj = getattr(obj, name) - except AttributeError: - # Happens e.g. in properties of - # PyQt4.QtGui.QStyleOptionComboBox.currentText - # -> just set it to None - obj = None - return create(evaluator, obj, parent_context=compiled_object, faked=faked) - - -def builtin_from_name(evaluator, string): - bltn_obj = getattr(_builtins, string) - return create(evaluator, bltn_obj) - - -def _a_generator(foo): - """Used to have an object to return for generators.""" - yield 42 - yield foo - - -_SPECIAL_OBJECTS = { - 'FUNCTION_CLASS': type(load_module), - 'METHOD_CLASS': type(CompiledObject.is_class), - 'MODULE_CLASS': type(os), - 'GENERATOR_OBJECT': _a_generator(1.0), - 'BUILTINS': _builtins, -} - - -def get_special_object(evaluator, identifier): - obj = _SPECIAL_OBJECTS[identifier] - return create(evaluator, obj, parent_context=create(evaluator, _builtins)) - - -def compiled_objects_cache(attribute_name): - def decorator(func): - """ - This decorator caches just the ids, oopposed to caching the object itself. - Caching the id has the advantage that an object doesn't need to be - hashable. - """ - def wrapper(evaluator, obj, parent_context=None, module=None, faked=None): - cache = getattr(evaluator, attribute_name) - # Do a very cheap form of caching here. - key = id(obj), id(parent_context) - try: - return cache[key][0] - except KeyError: - # TODO this whole decorator is way too ugly - result = func(evaluator, obj, parent_context, module, faked) - # Need to cache all of them, otherwise the id could be overwritten. - cache[key] = result, obj, parent_context, module, faked - return result - return wrapper - - return decorator - - -@compiled_objects_cache('compiled_cache') -def create(evaluator, obj, parent_context=None, module=None, faked=None): - """ - A very weird interface class to this module. The more options provided the - more acurate loading compiled objects is. - """ - if inspect.ismodule(obj): - if parent_context is not None: - # Modules don't have parents, be careful with caching: recurse. - return create(evaluator, obj) - else: - if parent_context is None and obj is not _builtins: - return create(evaluator, obj, create(evaluator, _builtins)) - - try: - faked = fake.get_faked(evaluator, module, obj, parent_context=parent_context) - if faked.type == 'funcdef': - from jedi.evaluate.context.function import FunctionContext - return FunctionContext(evaluator, parent_context, faked) - except fake.FakeDoesNotExist: - pass - - return CompiledObject(evaluator, obj, parent_context, faked) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake.py deleted file mode 100644 index 60dbefe..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake.py +++ /dev/null @@ -1,213 +0,0 @@ -""" -Loads functions that are mixed in to the standard library. E.g. builtins are -written in C (binaries), but my autocompletion only understands Python code. By -mixing in Python code, the autocompletion should work much better for builtins. -""" - -import os -import inspect -import types -from itertools import chain - -from parso.python import tree - -from jedi._compatibility import is_py3, builtins, unicode, is_py34 - -modules = {} - - -MethodDescriptorType = type(str.replace) -# These are not considered classes and access is granted even though they have -# a __class__ attribute. -NOT_CLASS_TYPES = ( - types.BuiltinFunctionType, - types.CodeType, - types.FrameType, - types.FunctionType, - types.GeneratorType, - types.GetSetDescriptorType, - types.LambdaType, - types.MemberDescriptorType, - types.MethodType, - types.ModuleType, - types.TracebackType, - MethodDescriptorType -) - -if is_py3: - NOT_CLASS_TYPES += ( - types.MappingProxyType, - types.SimpleNamespace - ) - if is_py34: - NOT_CLASS_TYPES += (types.DynamicClassAttribute,) - - -class FakeDoesNotExist(Exception): - pass - - -def _load_faked_module(grammar, module): - module_name = module.__name__ - if module_name == '__builtin__' and not is_py3: - module_name = 'builtins' - - try: - return modules[module_name] - except KeyError: - path = os.path.dirname(os.path.abspath(__file__)) - try: - with open(os.path.join(path, 'fake', module_name) + '.pym') as f: - source = f.read() - except IOError: - modules[module_name] = None - return - modules[module_name] = m = grammar.parse(unicode(source)) - - if module_name == 'builtins' and not is_py3: - # There are two implementations of `open` for either python 2/3. - # -> Rename the python2 version (`look at fake/builtins.pym`). - open_func = _search_scope(m, 'open') - open_func.children[1].value = 'open_python3' - open_func = _search_scope(m, 'open_python2') - open_func.children[1].value = 'open' - return m - - -def _search_scope(scope, obj_name): - for s in chain(scope.iter_classdefs(), scope.iter_funcdefs()): - if s.name.value == obj_name: - return s - - -def get_module(obj): - if inspect.ismodule(obj): - return obj - try: - obj = obj.__objclass__ - except AttributeError: - pass - - try: - imp_plz = obj.__module__ - except AttributeError: - # Unfortunately in some cases like `int` there's no __module__ - return builtins - else: - if imp_plz is None: - # Happens for example in `(_ for _ in []).send.__module__`. - return builtins - else: - try: - return __import__(imp_plz) - except ImportError: - # __module__ can be something arbitrary that doesn't exist. - return builtins - - -def _faked(grammar, module, obj, name): - # Crazy underscore actions to try to escape all the internal madness. - if module is None: - module = get_module(obj) - - faked_mod = _load_faked_module(grammar, module) - if faked_mod is None: - return None, None - - # Having the module as a `parser.python.tree.Module`, we need to scan - # for methods. - if name is None: - if inspect.isbuiltin(obj) or inspect.isclass(obj): - return _search_scope(faked_mod, obj.__name__), faked_mod - elif not inspect.isclass(obj): - # object is a method or descriptor - try: - objclass = obj.__objclass__ - except AttributeError: - return None, None - else: - cls = _search_scope(faked_mod, objclass.__name__) - if cls is None: - return None, None - return _search_scope(cls, obj.__name__), faked_mod - else: - if obj is module: - return _search_scope(faked_mod, name), faked_mod - else: - try: - cls_name = obj.__name__ - except AttributeError: - return None, None - cls = _search_scope(faked_mod, cls_name) - if cls is None: - return None, None - return _search_scope(cls, name), faked_mod - return None, None - - -def memoize_faked(obj): - """ - A typical memoize function that ignores issues with non hashable results. - """ - cache = obj.cache = {} - - def memoizer(*args, **kwargs): - key = (obj, args, frozenset(kwargs.items())) - try: - result = cache[key] - except (TypeError, ValueError): - return obj(*args, **kwargs) - except KeyError: - result = obj(*args, **kwargs) - if result is not None: - cache[key] = obj(*args, **kwargs) - return result - else: - return result - return memoizer - - -@memoize_faked -def _get_faked(grammar, module, obj, name=None): - result, fake_module = _faked(grammar, module, obj, name) - if result is None: - # We're not interested in classes. What we want is functions. - raise FakeDoesNotExist - elif result.type == 'classdef': - return result, fake_module - else: - # Set the docstr which was previously not set (faked modules don't - # contain it). - assert result.type == 'funcdef' - doc = '"""%s"""' % obj.__doc__ # TODO need escapes. - suite = result.children[-1] - string = tree.String(doc, (0, 0), '') - new_line = tree.Newline('\n', (0, 0)) - docstr_node = tree.PythonNode('simple_stmt', [string, new_line]) - suite.children.insert(1, docstr_node) - return result, fake_module - - -def get_faked(evaluator, module, obj, name=None, parent_context=None): - if parent_context and parent_context.tree_node is not None: - # Try to search in already clearly defined stuff. - found = _search_scope(parent_context.tree_node, name) - if found is not None: - return found - else: - raise FakeDoesNotExist - - faked, fake_module = _get_faked(evaluator.latest_grammar, module and module.obj, obj, name) - if module is not None: - module.get_used_names = fake_module.get_used_names - return faked - - -def is_class_instance(obj): - """Like inspect.* methods.""" - try: - cls = obj.__class__ - except AttributeError: - return False - else: - return cls != type and not issubclass(cls, NOT_CLASS_TYPES) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_functools.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_functools.pym deleted file mode 100644 index 909ef03..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_functools.pym +++ /dev/null @@ -1,9 +0,0 @@ -class partial(): - def __init__(self, func, *args, **keywords): - self.__func = func - self.__args = args - self.__keywords = keywords - - def __call__(self, *args, **kwargs): - # TODO should be **dict(self.__keywords, **kwargs) - return self.__func(*(self.__args + args), **self.__keywords) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_sqlite3.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_sqlite3.pym deleted file mode 100644 index 2151e65..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_sqlite3.pym +++ /dev/null @@ -1,26 +0,0 @@ -def connect(database, timeout=None, isolation_level=None, detect_types=None, factory=None): - return Connection() - - -class Connection(): - def cursor(self): - return Cursor() - - -class Cursor(): - def cursor(self): - return Cursor() - - def fetchone(self): - return Row() - - def fetchmany(self, size=cursor.arraysize): - return [self.fetchone()] - - def fetchall(self): - return [self.fetchone()] - - -class Row(): - def keys(self): - return [''] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_sre.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_sre.pym deleted file mode 100644 index 217be56..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_sre.pym +++ /dev/null @@ -1,99 +0,0 @@ -def compile(): - class SRE_Match(): - endpos = int() - lastgroup = int() - lastindex = int() - pos = int() - string = str() - regs = ((int(), int()),) - - def __init__(self, pattern): - self.re = pattern - - def start(self): - return int() - - def end(self): - return int() - - def span(self): - return int(), int() - - def expand(self): - return str() - - def group(self, nr): - return str() - - def groupdict(self): - return {str(): str()} - - def groups(self): - return (str(),) - - class SRE_Pattern(): - flags = int() - groupindex = {} - groups = int() - pattern = str() - - def findall(self, string, pos=None, endpos=None): - """ - findall(string[, pos[, endpos]]) --> list. - Return a list of all non-overlapping matches of pattern in string. - """ - return [str()] - - def finditer(self, string, pos=None, endpos=None): - """ - finditer(string[, pos[, endpos]]) --> iterator. - Return an iterator over all non-overlapping matches for the - RE pattern in string. For each match, the iterator returns a - match object. - """ - yield SRE_Match(self) - - def match(self, string, pos=None, endpos=None): - """ - match(string[, pos[, endpos]]) --> match object or None. - Matches zero or more characters at the beginning of the string - pattern - """ - return SRE_Match(self) - - def scanner(self, string, pos=None, endpos=None): - pass - - def search(self, string, pos=None, endpos=None): - """ - search(string[, pos[, endpos]]) --> match object or None. - Scan through string looking for a match, and return a corresponding - MatchObject instance. Return None if no position in the string matches. - """ - return SRE_Match(self) - - def split(self, string, maxsplit=0]): - """ - split(string[, maxsplit = 0]) --> list. - Split string by the occurrences of pattern. - """ - return [str()] - - def sub(self, repl, string, count=0): - """ - sub(repl, string[, count = 0]) --> newstring - Return the string obtained by replacing the leftmost non-overlapping - occurrences of pattern in string by the replacement repl. - """ - return str() - - def subn(self, repl, string, count=0): - """ - subn(repl, string[, count = 0]) --> (newstring, number of subs) - Return the tuple (new_string, number_of_subs_made) found by replacing - the leftmost non-overlapping occurrences of pattern with the - replacement repl. - """ - return (str(), int()) - - return SRE_Pattern() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_weakref.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_weakref.pym deleted file mode 100644 index 298d0b0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/_weakref.pym +++ /dev/null @@ -1,9 +0,0 @@ -def proxy(object, callback=None): - return object - -class ref(): - def __init__(self, object, callback=None): - self.__object = object - - def __call__(self): - return self.__object diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/builtins.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/builtins.pym deleted file mode 100644 index 1225929..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/builtins.pym +++ /dev/null @@ -1,274 +0,0 @@ -""" -Pure Python implementation of some builtins. -This code is not going to be executed anywhere. -These implementations are not always correct, but should work as good as -possible for the auto completion. -""" - - -def next(iterator, default=None): - if random.choice([0, 1]): - if hasattr("next"): - return iterator.next() - else: - return iterator.__next__() - else: - if default is not None: - return default - - -def iter(collection, sentinel=None): - if sentinel: - yield collection() - else: - for c in collection: - yield c - - -def range(start, stop=None, step=1): - return [0] - - -class file(): - def __iter__(self): - yield '' - - def next(self): - return '' - - def readlines(self): - return [''] - - def __enter__(self): - return self - - -class xrange(): - # Attention: this function doesn't exist in Py3k (there it is range). - def __iter__(self): - yield 1 - - def count(self): - return 1 - - def index(self): - return 1 - - -def open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True): - import io - return io.TextIOWrapper(file, mode, buffering, encoding, errors, newline, closefd) - - -def open_python2(name, mode=None, buffering=None): - return file(name, mode, buffering) - - -#-------------------------------------------------------- -# descriptors -#-------------------------------------------------------- -class property(): - def __init__(self, fget, fset=None, fdel=None, doc=None): - self.fget = fget - self.fset = fset - self.fdel = fdel - self.__doc__ = doc - - def __get__(self, obj, cls): - return self.fget(obj) - - def __set__(self, obj, value): - self.fset(obj, value) - - def __delete__(self, obj): - self.fdel(obj) - - def setter(self, func): - self.fset = func - return self - - def getter(self, func): - self.fget = func - return self - - def deleter(self, func): - self.fdel = func - return self - - -class staticmethod(): - def __init__(self, func): - self.__func = func - - def __get__(self, obj, cls): - return self.__func - - -class classmethod(): - def __init__(self, func): - self.__func = func - - def __get__(self, obj, cls): - def _method(*args, **kwargs): - return self.__func(cls, *args, **kwargs) - return _method - - -#-------------------------------------------------------- -# array stuff -#-------------------------------------------------------- -class list(): - def __init__(self, iterable=[]): - self.__iterable = [] - for i in iterable: - self.__iterable += [i] - - def __iter__(self): - for i in self.__iterable: - yield i - - def __getitem__(self, y): - return self.__iterable[y] - - def pop(self): - return self.__iterable[int()] - - -class tuple(): - def __init__(self, iterable=[]): - self.__iterable = [] - for i in iterable: - self.__iterable += [i] - - def __iter__(self): - for i in self.__iterable: - yield i - - def __getitem__(self, y): - return self.__iterable[y] - - def index(self): - return 1 - - def count(self): - return 1 - - -class set(): - def __init__(self, iterable=[]): - self.__iterable = iterable - - def __iter__(self): - for i in self.__iterable: - yield i - - def pop(self): - return list(self.__iterable)[-1] - - def copy(self): - return self - - def difference(self, other): - return self - other - - def intersection(self, other): - return self & other - - def symmetric_difference(self, other): - return self ^ other - - def union(self, other): - return self | other - - -class frozenset(): - def __init__(self, iterable=[]): - self.__iterable = iterable - - def __iter__(self): - for i in self.__iterable: - yield i - - def copy(self): - return self - - -class dict(): - def __init__(self, **elements): - self.__elements = elements - - def clear(self): - # has a strange docstr - pass - - def get(self, k, d=None): - # TODO implement - try: - #return self.__elements[k] - pass - except KeyError: - return d - - def values(self): - return self.__elements.values() - - def setdefault(self, k, d): - # TODO maybe also return the content - return d - - -class enumerate(): - def __init__(self, sequence, start=0): - self.__sequence = sequence - - def __iter__(self): - for i in self.__sequence: - yield 1, i - - def __next__(self): - return next(self.__iter__()) - - def next(self): - return next(self.__iter__()) - - -class reversed(): - def __init__(self, sequence): - self.__sequence = sequence - - def __iter__(self): - for i in self.__sequence: - yield i - - def __next__(self): - return next(self.__iter__()) - - def next(self): - return next(self.__iter__()) - - -def sorted(iterable, cmp=None, key=None, reverse=False): - return iterable - - -#-------------------------------------------------------- -# basic types -#-------------------------------------------------------- -class int(): - def __init__(self, x, base=None): - pass - - -class str(): - def __init__(self, obj): - pass - - def strip(self): - return str() - - def split(self): - return [str()] - -class type(): - def mro(): - return [object] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/datetime.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/datetime.pym deleted file mode 100644 index 823ac5b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/datetime.pym +++ /dev/null @@ -1,4 +0,0 @@ -class datetime(): - @staticmethod - def now(): - return datetime() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/io.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/io.pym deleted file mode 100644 index c1f4fc0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/io.pym +++ /dev/null @@ -1,12 +0,0 @@ -class TextIOWrapper(): - def __next__(self): - return str() - - def __iter__(self): - yield str() - - def readlines(self): - return [''] - - def __enter__(self): - return self diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/operator.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/operator.pym deleted file mode 100644 index d40d468..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/operator.pym +++ /dev/null @@ -1,33 +0,0 @@ -# Just copied this code from Python 3.6. - -class itemgetter: - """ - Return a callable object that fetches the given item(s) from its operand. - After f = itemgetter(2), the call f(r) returns r[2]. - After g = itemgetter(2, 5, 3), the call g(r) returns (r[2], r[5], r[3]) - """ - __slots__ = ('_items', '_call') - - def __init__(self, item, *items): - if not items: - self._items = (item,) - def func(obj): - return obj[item] - self._call = func - else: - self._items = items = (item,) + items - def func(obj): - return tuple(obj[i] for i in items) - self._call = func - - def __call__(self, obj): - return self._call(obj) - - def __repr__(self): - return '%s.%s(%s)' % (self.__class__.__module__, - self.__class__.__name__, - ', '.join(map(repr, self._items))) - - def __reduce__(self): - return self.__class__, self._items - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/posix.pym b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/posix.pym deleted file mode 100644 index 4417f7c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/fake/posix.pym +++ /dev/null @@ -1,5 +0,0 @@ -def getcwd(): - return '' - -def getcwdu(): - return '' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/getattr_static.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/getattr_static.py deleted file mode 100644 index 9f8cd8a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/getattr_static.py +++ /dev/null @@ -1,175 +0,0 @@ -""" -A static version of getattr. -This is a backport of the Python 3 code with a little bit of additional -information returned to enable Jedi to make decisions. -""" - -import types - -from jedi._compatibility import py_version - -_sentinel = object() - -def _check_instance(obj, attr): - instance_dict = {} - try: - instance_dict = object.__getattribute__(obj, "__dict__") - except AttributeError: - pass - return dict.get(instance_dict, attr, _sentinel) - - -def _check_class(klass, attr): - for entry in _static_getmro(klass): - if _shadowed_dict(type(entry)) is _sentinel: - try: - return entry.__dict__[attr] - except KeyError: - pass - return _sentinel - -def _is_type(obj): - try: - _static_getmro(obj) - except TypeError: - return False - return True - - -def _shadowed_dict_newstyle(klass): - dict_attr = type.__dict__["__dict__"] - for entry in _static_getmro(klass): - try: - class_dict = dict_attr.__get__(entry)["__dict__"] - except KeyError: - pass - else: - if not (type(class_dict) is types.GetSetDescriptorType and - class_dict.__name__ == "__dict__" and - class_dict.__objclass__ is entry): - return class_dict - return _sentinel - - -def _static_getmro_newstyle(klass): - return type.__dict__['__mro__'].__get__(klass) - - -if py_version >= 30: - _shadowed_dict = _shadowed_dict_newstyle - _get_type = type - _static_getmro = _static_getmro_newstyle -else: - def _shadowed_dict(klass): - """ - In Python 2 __dict__ is not overwritable: - - class Foo(object): pass - setattr(Foo, '__dict__', 4) - - Traceback (most recent call last): - File "", line 1, in - TypeError: __dict__ must be a dictionary object - - It applies to both newstyle and oldstyle classes: - - class Foo(object): pass - setattr(Foo, '__dict__', 4) - Traceback (most recent call last): - File "", line 1, in - AttributeError: attribute '__dict__' of 'type' objects is not writable - - It also applies to instances of those objects. However to keep things - straight forward, newstyle classes always use the complicated way of - accessing it while oldstyle classes just use getattr. - """ - if type(klass) is _oldstyle_class_type: - return getattr(klass, '__dict__', _sentinel) - return _shadowed_dict_newstyle(klass) - - class _OldStyleClass(): - pass - - _oldstyle_instance_type = type(_OldStyleClass()) - _oldstyle_class_type = type(_OldStyleClass) - - def _get_type(obj): - type_ = object.__getattribute__(obj, '__class__') - if type_ is _oldstyle_instance_type: - # Somehow for old style classes we need to access it directly. - return obj.__class__ - return type_ - - def _static_getmro(klass): - if type(klass) is _oldstyle_class_type: - def oldstyle_mro(klass): - """ - Oldstyle mro is a really simplistic way of look up mro: - https://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python - """ - yield klass - for base in klass.__bases__: - for yield_from in oldstyle_mro(base): - yield yield_from - - return oldstyle_mro(klass) - - return _static_getmro_newstyle(klass) - - -def _safe_hasattr(obj, name): - return _check_class(_get_type(obj), name) is not _sentinel - - -def _safe_is_data_descriptor(obj): - return (_safe_hasattr(obj, '__set__') or _safe_hasattr(obj, '__delete__')) - - -def getattr_static(obj, attr, default=_sentinel): - """Retrieve attributes without triggering dynamic lookup via the - descriptor protocol, __getattr__ or __getattribute__. - - Note: this function may not be able to retrieve all attributes - that getattr can fetch (like dynamically created attributes) - and may find attributes that getattr can't (like descriptors - that raise AttributeError). It can also return descriptor objects - instead of instance members in some cases. See the - documentation for details. - - Returns a tuple `(attr, is_get_descriptor)`. is_get_descripter means that - the attribute is a descriptor that has a `__get__` attribute. - """ - instance_result = _sentinel - if not _is_type(obj): - klass = _get_type(obj) - dict_attr = _shadowed_dict(klass) - if (dict_attr is _sentinel or - type(dict_attr) is types.MemberDescriptorType): - instance_result = _check_instance(obj, attr) - else: - klass = obj - - klass_result = _check_class(klass, attr) - - if instance_result is not _sentinel and klass_result is not _sentinel: - if _safe_hasattr(klass_result, '__get__') \ - and _safe_is_data_descriptor(klass_result): - # A get/set descriptor has priority over everything. - return klass_result, True - - if instance_result is not _sentinel: - return instance_result, False - if klass_result is not _sentinel: - return klass_result, _safe_hasattr(klass_result, '__get__') - - if obj is klass: - # for types we check the metaclass too - for entry in _static_getmro(type(klass)): - if _shadowed_dict(type(entry)) is _sentinel: - try: - return entry.__dict__[attr], False - except KeyError: - pass - if default is not _sentinel: - return default, False - raise AttributeError(attr) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/mixed.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/mixed.py deleted file mode 100644 index ac0f6dd..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/compiled/mixed.py +++ /dev/null @@ -1,231 +0,0 @@ -""" -Used only for REPL Completion. -""" - -import inspect -import os - -from jedi import settings -from jedi.evaluate import compiled -from jedi.cache import underscore_memoization -from jedi.evaluate import imports -from jedi.evaluate.base_context import Context, ContextSet -from jedi.evaluate.context import ModuleContext -from jedi.evaluate.cache import evaluator_function_cache -from jedi.evaluate.compiled.getattr_static import getattr_static - - -class MixedObject(object): - """ - A ``MixedObject`` is used in two ways: - - 1. It uses the default logic of ``parser.python.tree`` objects, - 2. except for getattr calls. The names dicts are generated in a fashion - like ``CompiledObject``. - - This combined logic makes it possible to provide more powerful REPL - completion. It allows side effects that are not noticable with the default - parser structure to still be completeable. - - The biggest difference from CompiledObject to MixedObject is that we are - generally dealing with Python code and not with C code. This will generate - fewer special cases, because we in Python you don't have the same freedoms - to modify the runtime. - """ - def __init__(self, evaluator, parent_context, compiled_object, tree_context): - self.evaluator = evaluator - self.parent_context = parent_context - self.compiled_object = compiled_object - self._context = tree_context - self.obj = compiled_object.obj - - # We have to overwrite everything that has to do with trailers, name - # lookups and filters to make it possible to route name lookups towards - # compiled objects and the rest towards tree node contexts. - def py__getattribute__(*args, **kwargs): - return Context.py__getattribute__(*args, **kwargs) - - def get_filters(self, *args, **kwargs): - yield MixedObjectFilter(self.evaluator, self) - - def __repr__(self): - return '<%s: %s>' % (type(self).__name__, repr(self.obj)) - - def __getattr__(self, name): - return getattr(self._context, name) - - -class MixedName(compiled.CompiledName): - """ - The ``CompiledName._compiled_object`` is our MixedObject. - """ - @property - def start_pos(self): - contexts = list(self.infer()) - if not contexts: - # This means a start_pos that doesn't exist (compiled objects). - return (0, 0) - return contexts[0].name.start_pos - - @start_pos.setter - def start_pos(self, value): - # Ignore the __init__'s start_pos setter call. - pass - - @underscore_memoization - def infer(self): - obj = self.parent_context.obj - try: - # TODO use logic from compiled.CompiledObjectFilter - obj = getattr(obj, self.string_name) - except AttributeError: - # Happens e.g. in properties of - # PyQt4.QtGui.QStyleOptionComboBox.currentText - # -> just set it to None - obj = None - return ContextSet( - _create(self._evaluator, obj, parent_context=self.parent_context) - ) - - @property - def api_type(self): - return next(iter(self.infer())).api_type - - -class MixedObjectFilter(compiled.CompiledObjectFilter): - name_class = MixedName - - def __init__(self, evaluator, mixed_object, is_instance=False): - super(MixedObjectFilter, self).__init__( - evaluator, mixed_object, is_instance) - self._mixed_object = mixed_object - - #def _create(self, name): - #return MixedName(self._evaluator, self._compiled_object, name) - - -@evaluator_function_cache() -def _load_module(evaluator, path, python_object): - module = evaluator.grammar.parse( - path=path, - cache=True, - diff_cache=True, - cache_path=settings.cache_directory - ).get_root_node() - python_module = inspect.getmodule(python_object) - - evaluator.modules[python_module.__name__] = module - return module - - -def _get_object_to_check(python_object): - """Check if inspect.getfile has a chance to find the source.""" - if (inspect.ismodule(python_object) or - inspect.isclass(python_object) or - inspect.ismethod(python_object) or - inspect.isfunction(python_object) or - inspect.istraceback(python_object) or - inspect.isframe(python_object) or - inspect.iscode(python_object)): - return python_object - - try: - return python_object.__class__ - except AttributeError: - raise TypeError # Prevents computation of `repr` within inspect. - - -def find_syntax_node_name(evaluator, python_object): - try: - python_object = _get_object_to_check(python_object) - path = inspect.getsourcefile(python_object) - except TypeError: - # The type might not be known (e.g. class_with_dict.__weakref__) - return None, None - if path is None or not os.path.exists(path): - # The path might not exist or be e.g. . - return None, None - - module = _load_module(evaluator, path, python_object) - - if inspect.ismodule(python_object): - # We don't need to check names for modules, because there's not really - # a way to write a module in a module in Python (and also __name__ can - # be something like ``email.utils``). - return module, path - - try: - name_str = python_object.__name__ - except AttributeError: - # Stuff like python_function.__code__. - return None, None - - if name_str == '': - return None, None # It's too hard to find lambdas. - - # Doesn't always work (e.g. os.stat_result) - try: - names = module.get_used_names()[name_str] - except KeyError: - return None, None - names = [n for n in names if n.is_definition()] - - try: - code = python_object.__code__ - # By using the line number of a code object we make the lookup in a - # file pretty easy. There's still a possibility of people defining - # stuff like ``a = 3; foo(a); a = 4`` on the same line, but if people - # do so we just don't care. - line_nr = code.co_firstlineno - except AttributeError: - pass - else: - line_names = [name for name in names if name.start_pos[0] == line_nr] - # There's a chance that the object is not available anymore, because - # the code has changed in the background. - if line_names: - return line_names[-1].parent, path - - # It's really hard to actually get the right definition, here as a last - # resort we just return the last one. This chance might lead to odd - # completions at some points but will lead to mostly correct type - # inference, because people tend to define a public name in a module only - # once. - return names[-1].parent, path - - -@compiled.compiled_objects_cache('mixed_cache') -def _create(evaluator, obj, parent_context=None, *args): - tree_node, path = find_syntax_node_name(evaluator, obj) - - compiled_object = compiled.create( - evaluator, obj, parent_context=parent_context.compiled_object) - if tree_node is None: - return compiled_object - - module_node = tree_node.get_root_node() - if parent_context.tree_node.get_root_node() == module_node: - module_context = parent_context.get_root_context() - else: - module_context = ModuleContext(evaluator, module_node, path=path) - # TODO this __name__ is probably wrong. - name = compiled_object.get_root_context().py__name__() - imports.add_module(evaluator, name, module_context) - - tree_context = module_context.create_context( - tree_node, - node_is_context=True, - node_is_object=True - ) - if tree_node.type == 'classdef': - if not inspect.isclass(obj): - # Is an instance, not a class. - tree_context, = tree_context.execute_evaluated() - - return MixedObject( - evaluator, - parent_context, - compiled_object, - tree_context=tree_context - ) - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/__init__.py deleted file mode 100644 index 4e7ce4d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from jedi.evaluate.context.module import ModuleContext -from jedi.evaluate.context.klass import ClassContext -from jedi.evaluate.context.function import FunctionContext, FunctionExecutionContext -from jedi.evaluate.context.instance import AnonymousInstance, BoundMethod, \ - CompiledInstance, AbstractInstanceContext, TreeInstance diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/function.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/function.py deleted file mode 100644 index 0dba9c9..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/function.py +++ /dev/null @@ -1,226 +0,0 @@ -from parso.python import tree - -from jedi._compatibility import use_metaclass -from jedi import debug -from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass -from jedi.evaluate import compiled -from jedi.evaluate import recursion -from jedi.evaluate import docstrings -from jedi.evaluate import pep0484 -from jedi.evaluate import flow_analysis -from jedi.evaluate import helpers -from jedi.evaluate.arguments import AnonymousArguments -from jedi.evaluate.filters import ParserTreeFilter, FunctionExecutionFilter, \ - ContextName, AbstractNameDefinition, ParamName -from jedi.evaluate.base_context import ContextualizedNode, NO_CONTEXTS, \ - ContextSet, TreeContext -from jedi.evaluate.lazy_context import LazyKnownContexts, LazyKnownContext, \ - LazyTreeContext -from jedi.evaluate.context import iterable -from jedi import parser_utils -from jedi.evaluate.parser_cache import get_yield_exprs - - -class LambdaName(AbstractNameDefinition): - string_name = '' - - def __init__(self, lambda_context): - self._lambda_context = lambda_context - self.parent_context = lambda_context.parent_context - - def start_pos(self): - return self._lambda_context.tree_node.start_pos - - def infer(self): - return ContextSet(self._lambda_context) - - -class FunctionContext(use_metaclass(CachedMetaClass, TreeContext)): - """ - Needed because of decorators. Decorators are evaluated here. - """ - api_type = 'function' - - def __init__(self, evaluator, parent_context, funcdef): - """ This should not be called directly """ - super(FunctionContext, self).__init__(evaluator, parent_context) - self.tree_node = funcdef - - def get_filters(self, search_global, until_position=None, origin_scope=None): - if search_global: - yield ParserTreeFilter( - self.evaluator, - context=self, - until_position=until_position, - origin_scope=origin_scope - ) - else: - scope = self.py__class__() - for filter in scope.get_filters(search_global=False, origin_scope=origin_scope): - yield filter - - def infer_function_execution(self, function_execution): - """ - Created to be used by inheritance. - """ - yield_exprs = get_yield_exprs(self.evaluator, self.tree_node) - if yield_exprs: - return ContextSet(iterable.Generator(self.evaluator, function_execution)) - else: - return function_execution.get_return_values() - - def get_function_execution(self, arguments=None): - if arguments is None: - arguments = AnonymousArguments() - - return FunctionExecutionContext(self.evaluator, self.parent_context, self, arguments) - - def py__call__(self, arguments): - function_execution = self.get_function_execution(arguments) - return self.infer_function_execution(function_execution) - - def py__class__(self): - # This differentiation is only necessary for Python2. Python3 does not - # use a different method class. - if isinstance(parser_utils.get_parent_scope(self.tree_node), tree.Class): - name = 'METHOD_CLASS' - else: - name = 'FUNCTION_CLASS' - return compiled.get_special_object(self.evaluator, name) - - @property - def name(self): - if self.tree_node.type == 'lambdef': - return LambdaName(self) - return ContextName(self, self.tree_node.name) - - def get_param_names(self): - function_execution = self.get_function_execution() - return [ParamName(function_execution, param.name) - for param in self.tree_node.get_params()] - - -class FunctionExecutionContext(TreeContext): - """ - This class is used to evaluate functions and their returns. - - This is the most complicated class, because it contains the logic to - transfer parameters. It is even more complicated, because there may be - multiple calls to functions and recursion has to be avoided. But this is - responsibility of the decorators. - """ - function_execution_filter = FunctionExecutionFilter - - def __init__(self, evaluator, parent_context, function_context, var_args): - super(FunctionExecutionContext, self).__init__(evaluator, parent_context) - self.function_context = function_context - self.tree_node = function_context.tree_node - self.var_args = var_args - - @evaluator_method_cache(default=NO_CONTEXTS) - @recursion.execution_recursion_decorator() - def get_return_values(self, check_yields=False): - funcdef = self.tree_node - if funcdef.type == 'lambdef': - return self.evaluator.eval_element(self, funcdef.children[-1]) - - if check_yields: - context_set = NO_CONTEXTS - returns = get_yield_exprs(self.evaluator, funcdef) - else: - returns = funcdef.iter_return_stmts() - context_set = docstrings.infer_return_types(self.function_context) - context_set |= pep0484.infer_return_types(self.function_context) - - for r in returns: - check = flow_analysis.reachability_check(self, funcdef, r) - if check is flow_analysis.UNREACHABLE: - debug.dbg('Return unreachable: %s', r) - else: - if check_yields: - context_set |= ContextSet.from_sets( - lazy_context.infer() - for lazy_context in self._eval_yield(r) - ) - else: - try: - children = r.children - except AttributeError: - context_set |= ContextSet(compiled.create(self.evaluator, None)) - else: - context_set |= self.eval_node(children[1]) - if check is flow_analysis.REACHABLE: - debug.dbg('Return reachable: %s', r) - break - return context_set - - def _eval_yield(self, yield_expr): - if yield_expr.type == 'keyword': - # `yield` just yields None. - yield LazyKnownContext(compiled.create(self.evaluator, None)) - return - - node = yield_expr.children[1] - if node.type == 'yield_arg': # It must be a yield from. - cn = ContextualizedNode(self, node.children[1]) - for lazy_context in cn.infer().iterate(cn): - yield lazy_context - else: - yield LazyTreeContext(self, node) - - @recursion.execution_recursion_decorator(default=iter([])) - def get_yield_values(self): - for_parents = [(y, tree.search_ancestor(y, 'for_stmt', 'funcdef', - 'while_stmt', 'if_stmt')) - for y in get_yield_exprs(self.evaluator, self.tree_node)] - - # Calculate if the yields are placed within the same for loop. - yields_order = [] - last_for_stmt = None - for yield_, for_stmt in for_parents: - # For really simple for loops we can predict the order. Otherwise - # we just ignore it. - parent = for_stmt.parent - if parent.type == 'suite': - parent = parent.parent - if for_stmt.type == 'for_stmt' and parent == self.tree_node \ - and parser_utils.for_stmt_defines_one_name(for_stmt): # Simplicity for now. - if for_stmt == last_for_stmt: - yields_order[-1][1].append(yield_) - else: - yields_order.append((for_stmt, [yield_])) - elif for_stmt == self.tree_node: - yields_order.append((None, [yield_])) - else: - types = self.get_return_values(check_yields=True) - if types: - yield LazyKnownContexts(types) - return - last_for_stmt = for_stmt - - for for_stmt, yields in yields_order: - if for_stmt is None: - # No for_stmt, just normal yields. - for yield_ in yields: - for result in self._eval_yield(yield_): - yield result - else: - input_node = for_stmt.get_testlist() - cn = ContextualizedNode(self, input_node) - ordered = cn.infer().iterate(cn) - ordered = list(ordered) - for lazy_context in ordered: - dct = {str(for_stmt.children[1].value): lazy_context.infer()} - with helpers.predefine_names(self, for_stmt, dct): - for yield_in_same_for_stmt in yields: - for result in self._eval_yield(yield_in_same_for_stmt): - yield result - - def get_filters(self, search_global, until_position=None, origin_scope=None): - yield self.function_execution_filter(self.evaluator, self, - until_position=until_position, - origin_scope=origin_scope) - - @evaluator_method_cache() - def get_params(self): - return self.var_args.get_params(self) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/instance.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/instance.py deleted file mode 100644 index 2c8d796..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/instance.py +++ /dev/null @@ -1,435 +0,0 @@ -from abc import abstractproperty - -from jedi._compatibility import is_py3 -from jedi import debug -from jedi.evaluate import compiled -from jedi.evaluate import filters -from jedi.evaluate.base_context import Context, NO_CONTEXTS, ContextSet, \ - iterator_to_context_set -from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.arguments import AbstractArguments, AnonymousArguments -from jedi.cache import memoize_method -from jedi.evaluate.context.function import FunctionExecutionContext, FunctionContext -from jedi.evaluate.context.klass import ClassContext, apply_py__get__ -from jedi.evaluate.context import iterable -from jedi.parser_utils import get_parent_scope - - - -class InstanceFunctionExecution(FunctionExecutionContext): - def __init__(self, instance, parent_context, function_context, var_args): - self.instance = instance - var_args = InstanceVarArgs(self, var_args) - - super(InstanceFunctionExecution, self).__init__( - instance.evaluator, parent_context, function_context, var_args) - - -class AnonymousInstanceFunctionExecution(FunctionExecutionContext): - function_execution_filter = filters.AnonymousInstanceFunctionExecutionFilter - - def __init__(self, instance, parent_context, function_context, var_args): - self.instance = instance - super(AnonymousInstanceFunctionExecution, self).__init__( - instance.evaluator, parent_context, function_context, var_args) - - -class AbstractInstanceContext(Context): - """ - This class is used to evaluate instances. - """ - api_type = 'instance' - function_execution_cls = InstanceFunctionExecution - - def __init__(self, evaluator, parent_context, class_context, var_args): - super(AbstractInstanceContext, self).__init__(evaluator, parent_context) - # Generated instances are classes that are just generated by self - # (No var_args) used. - self.class_context = class_context - self.var_args = var_args - - def is_class(self): - return False - - @property - def py__call__(self): - names = self.get_function_slot_names('__call__') - if not names: - # Means the Instance is not callable. - raise AttributeError - - def execute(arguments): - return ContextSet.from_sets(name.execute(arguments) for name in names) - - return execute - - def py__class__(self): - return self.class_context - - def py__bool__(self): - # Signalize that we don't know about the bool type. - return None - - def get_function_slot_names(self, name): - # Python classes don't look at the dictionary of the instance when - # looking up `__call__`. This is something that has to do with Python's - # internal slot system (note: not __slots__, but C slots). - for filter in self.get_filters(include_self_names=False): - names = filter.get(name) - if names: - return names - return [] - - def execute_function_slots(self, names, *evaluated_args): - return ContextSet.from_sets( - name.execute_evaluated(*evaluated_args) - for name in names - ) - - def py__get__(self, obj): - # Arguments in __get__ descriptors are obj, class. - # `method` is the new parent of the array, don't know if that's good. - names = self.get_function_slot_names('__get__') - if names: - if isinstance(obj, AbstractInstanceContext): - return self.execute_function_slots(names, obj, obj.class_context) - else: - none_obj = compiled.create(self.evaluator, None) - return self.execute_function_slots(names, none_obj, obj) - else: - return ContextSet(self) - - def get_filters(self, search_global=None, until_position=None, - origin_scope=None, include_self_names=True): - if include_self_names: - for cls in self.class_context.py__mro__(): - if isinstance(cls, compiled.CompiledObject): - if cls.tree_node is not None: - # In this case we're talking about a fake object, it - # doesn't make sense for normal compiled objects to - # search for self variables. - yield SelfNameFilter(self.evaluator, self, cls, origin_scope) - else: - yield SelfNameFilter(self.evaluator, self, cls, origin_scope) - - for cls in self.class_context.py__mro__(): - if isinstance(cls, compiled.CompiledObject): - yield CompiledInstanceClassFilter(self.evaluator, self, cls) - else: - yield InstanceClassFilter(self.evaluator, self, cls, origin_scope) - - def py__getitem__(self, index): - try: - names = self.get_function_slot_names('__getitem__') - except KeyError: - debug.warning('No __getitem__, cannot access the array.') - return NO_CONTEXTS - else: - index_obj = compiled.create(self.evaluator, index) - return self.execute_function_slots(names, index_obj) - - def py__iter__(self): - iter_slot_names = self.get_function_slot_names('__iter__') - if not iter_slot_names: - debug.warning('No __iter__ on %s.' % self) - return - - for generator in self.execute_function_slots(iter_slot_names): - if isinstance(generator, AbstractInstanceContext): - # `__next__` logic. - name = '__next__' if is_py3 else 'next' - iter_slot_names = generator.get_function_slot_names(name) - if iter_slot_names: - yield LazyKnownContexts( - generator.execute_function_slots(iter_slot_names) - ) - else: - debug.warning('Instance has no __next__ function in %s.', generator) - else: - for lazy_context in generator.py__iter__(): - yield lazy_context - - @abstractproperty - def name(self): - pass - - def _create_init_execution(self, class_context, func_node): - bound_method = BoundMethod( - self.evaluator, self, class_context, self.parent_context, func_node - ) - return self.function_execution_cls( - self, - class_context.parent_context, - bound_method, - self.var_args - ) - - def create_init_executions(self): - for name in self.get_function_slot_names('__init__'): - if isinstance(name, LazyInstanceName): - yield self._create_init_execution(name.class_context, name.tree_name.parent) - - @evaluator_method_cache() - def create_instance_context(self, class_context, node): - if node.parent.type in ('funcdef', 'classdef'): - node = node.parent - scope = get_parent_scope(node) - if scope == class_context.tree_node: - return class_context - else: - parent_context = self.create_instance_context(class_context, scope) - if scope.type == 'funcdef': - if scope.name.value == '__init__' and parent_context == class_context: - return self._create_init_execution(class_context, scope) - else: - bound_method = BoundMethod( - self.evaluator, self, class_context, - parent_context, scope - ) - return bound_method.get_function_execution() - elif scope.type == 'classdef': - class_context = ClassContext(self.evaluator, scope, parent_context) - return class_context - elif scope.type == 'comp_for': - # Comprehensions currently don't have a special scope in Jedi. - return self.create_instance_context(class_context, scope) - else: - raise NotImplementedError - return class_context - - def __repr__(self): - return "<%s of %s(%s)>" % (self.__class__.__name__, self.class_context, - self.var_args) - - -class CompiledInstance(AbstractInstanceContext): - def __init__(self, *args, **kwargs): - super(CompiledInstance, self).__init__(*args, **kwargs) - # I don't think that dynamic append lookups should happen here. That - # sounds more like something that should go to py__iter__. - if self.class_context.name.string_name in ['list', 'set'] \ - and self.parent_context.get_root_context() == self.evaluator.BUILTINS: - # compare the module path with the builtin name. - self.var_args = iterable.get_dynamic_array_instance(self) - - @property - def name(self): - return compiled.CompiledContextName(self, self.class_context.name.string_name) - - def create_instance_context(self, class_context, node): - if get_parent_scope(node).type == 'classdef': - return class_context - else: - return super(CompiledInstance, self).create_instance_context(class_context, node) - - -class TreeInstance(AbstractInstanceContext): - def __init__(self, evaluator, parent_context, class_context, var_args): - super(TreeInstance, self).__init__(evaluator, parent_context, - class_context, var_args) - self.tree_node = class_context.tree_node - - @property - def name(self): - return filters.ContextName(self, self.class_context.name.tree_name) - - -class AnonymousInstance(TreeInstance): - function_execution_cls = AnonymousInstanceFunctionExecution - - def __init__(self, evaluator, parent_context, class_context): - super(AnonymousInstance, self).__init__( - evaluator, - parent_context, - class_context, - var_args=AnonymousArguments(), - ) - - -class CompiledInstanceName(compiled.CompiledName): - def __init__(self, evaluator, instance, parent_context, name): - super(CompiledInstanceName, self).__init__(evaluator, parent_context, name) - self._instance = instance - - @iterator_to_context_set - def infer(self): - for result_context in super(CompiledInstanceName, self).infer(): - if isinstance(result_context, FunctionContext): - parent_context = result_context.parent_context - while parent_context.is_class(): - parent_context = parent_context.parent_context - - yield BoundMethod( - result_context.evaluator, self._instance, self.parent_context, - parent_context, result_context.tree_node - ) - else: - if result_context.api_type == 'function': - yield CompiledBoundMethod(result_context) - else: - yield result_context - - -class CompiledInstanceClassFilter(compiled.CompiledObjectFilter): - name_class = CompiledInstanceName - - def __init__(self, evaluator, instance, compiled_object): - super(CompiledInstanceClassFilter, self).__init__( - evaluator, - compiled_object, - is_instance=True, - ) - self._instance = instance - - def _create_name(self, name): - return self.name_class( - self._evaluator, self._instance, self._compiled_object, name) - - -class BoundMethod(FunctionContext): - def __init__(self, evaluator, instance, class_context, *args, **kwargs): - super(BoundMethod, self).__init__(evaluator, *args, **kwargs) - self._instance = instance - self._class_context = class_context - - def get_function_execution(self, arguments=None): - if arguments is None: - arguments = AnonymousArguments() - return AnonymousInstanceFunctionExecution( - self._instance, self.parent_context, self, arguments) - else: - return InstanceFunctionExecution( - self._instance, self.parent_context, self, arguments) - - -class CompiledBoundMethod(compiled.CompiledObject): - def __init__(self, func): - super(CompiledBoundMethod, self).__init__( - func.evaluator, func.obj, func.parent_context, func.tree_node) - - def get_param_names(self): - return list(super(CompiledBoundMethod, self).get_param_names())[1:] - - -class InstanceNameDefinition(filters.TreeNameDefinition): - def infer(self): - return super(InstanceNameDefinition, self).infer() - - -class LazyInstanceName(filters.TreeNameDefinition): - """ - This name calculates the parent_context lazily. - """ - def __init__(self, instance, class_context, tree_name): - self._instance = instance - self.class_context = class_context - self.tree_name = tree_name - - @property - def parent_context(self): - return self._instance.create_instance_context(self.class_context, self.tree_name) - - -class LazyInstanceClassName(LazyInstanceName): - @iterator_to_context_set - def infer(self): - for result_context in super(LazyInstanceClassName, self).infer(): - if isinstance(result_context, FunctionContext): - # Classes are never used to resolve anything within the - # functions. Only other functions and modules will resolve - # those things. - parent_context = result_context.parent_context - while parent_context.is_class(): - parent_context = parent_context.parent_context - - yield BoundMethod( - result_context.evaluator, self._instance, self.class_context, - parent_context, result_context.tree_node - ) - else: - for c in apply_py__get__(result_context, self._instance): - yield c - - -class InstanceClassFilter(filters.ParserTreeFilter): - name_class = LazyInstanceClassName - - def __init__(self, evaluator, context, class_context, origin_scope): - super(InstanceClassFilter, self).__init__( - evaluator=evaluator, - context=context, - node_context=class_context, - origin_scope=origin_scope - ) - self._class_context = class_context - - def _equals_origin_scope(self): - node = self._origin_scope - while node is not None: - if node == self._parser_scope or node == self.context: - return True - node = get_parent_scope(node) - return False - - def _access_possible(self, name): - return not name.value.startswith('__') or name.value.endswith('__') \ - or self._equals_origin_scope() - - def _filter(self, names): - names = super(InstanceClassFilter, self)._filter(names) - return [name for name in names if self._access_possible(name)] - - def _convert_names(self, names): - return [self.name_class(self.context, self._class_context, name) for name in names] - - -class SelfNameFilter(InstanceClassFilter): - name_class = LazyInstanceName - - def _filter(self, names): - names = self._filter_self_names(names) - if isinstance(self._parser_scope, compiled.CompiledObject) and False: - # This would be for builtin skeletons, which are not yet supported. - return list(names) - else: - start, end = self._parser_scope.start_pos, self._parser_scope.end_pos - return [n for n in names if start < n.start_pos < end] - - def _filter_self_names(self, names): - for name in names: - trailer = name.parent - if trailer.type == 'trailer' \ - and len(trailer.children) == 2 \ - and trailer.children[0] == '.': - if name.is_definition() and self._access_possible(name): - yield name - - def _check_flows(self, names): - return names - - -class InstanceVarArgs(AbstractArguments): - def __init__(self, execution_context, var_args): - self._execution_context = execution_context - self._var_args = var_args - - @memoize_method - def _get_var_args(self): - return self._var_args - - @property - def argument_node(self): - return self._var_args.argument_node - - @property - def trailer(self): - return self._var_args.trailer - - def unpack(self, func=None): - yield None, LazyKnownContext(self._execution_context.instance) - for values in self._get_var_args().unpack(func): - yield values - - def get_calling_nodes(self): - return self._get_var_args().get_calling_nodes() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/iterable.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/iterable.py deleted file mode 100644 index d0f468e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/iterable.py +++ /dev/null @@ -1,691 +0,0 @@ -""" -Contains all classes and functions to deal with lists, dicts, generators and -iterators in general. - -Array modifications -******************* - -If the content of an array (``set``/``list``) is requested somewhere, the -current module will be checked for appearances of ``arr.append``, -``arr.insert``, etc. If the ``arr`` name points to an actual array, the -content will be added - -This can be really cpu intensive, as you can imagine. Because |jedi| has to -follow **every** ``append`` and check wheter it's the right array. However this -works pretty good, because in *slow* cases, the recursion detector and other -settings will stop this process. - -It is important to note that: - -1. Array modfications work only in the current module. -2. Jedi only checks Array additions; ``list.pop``, etc are ignored. -""" -from jedi import debug -from jedi import settings -from jedi.evaluate import compiled -from jedi.evaluate import analysis -from jedi.evaluate import recursion -from jedi.evaluate.lazy_context import LazyKnownContext, LazyKnownContexts, \ - LazyTreeContext -from jedi.evaluate.helpers import is_string, predefine_names, evaluate_call_of_leaf -from jedi.evaluate.utils import safe_property -from jedi.evaluate.utils import to_list -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.filters import ParserTreeFilter, has_builtin_methods, \ - register_builtin_method, SpecialMethodFilter -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, Context, \ - TreeContext, ContextualizedNode -from jedi.parser_utils import get_comp_fors - - -class AbstractIterable(Context): - builtin_methods = {} - api_type = 'instance' - - def __init__(self, evaluator): - super(AbstractIterable, self).__init__(evaluator, evaluator.BUILTINS) - - def get_filters(self, search_global, until_position=None, origin_scope=None): - raise NotImplementedError - - @property - def name(self): - return compiled.CompiledContextName(self, self.array_type) - - -@has_builtin_methods -class GeneratorMixin(object): - array_type = None - - @register_builtin_method('send') - @register_builtin_method('next', python_version_match=2) - @register_builtin_method('__next__', python_version_match=3) - def py__next__(self): - # TODO add TypeError if params are given. - return ContextSet.from_sets(lazy_context.infer() for lazy_context in self.py__iter__()) - - def get_filters(self, search_global, until_position=None, origin_scope=None): - gen_obj = compiled.get_special_object(self.evaluator, 'GENERATOR_OBJECT') - yield SpecialMethodFilter(self, self.builtin_methods, gen_obj) - for filter in gen_obj.get_filters(search_global): - yield filter - - def py__bool__(self): - return True - - def py__class__(self): - gen_obj = compiled.get_special_object(self.evaluator, 'GENERATOR_OBJECT') - return gen_obj.py__class__() - - @property - def name(self): - return compiled.CompiledContextName(self, 'generator') - - -class Generator(GeneratorMixin, Context): - """Handling of `yield` functions.""" - def __init__(self, evaluator, func_execution_context): - super(Generator, self).__init__(evaluator, parent_context=evaluator.BUILTINS) - self._func_execution_context = func_execution_context - - def py__iter__(self): - return self._func_execution_context.get_yield_values() - - def __repr__(self): - return "<%s of %s>" % (type(self).__name__, self._func_execution_context) - - -class CompForContext(TreeContext): - @classmethod - def from_comp_for(cls, parent_context, comp_for): - return cls(parent_context.evaluator, parent_context, comp_for) - - def __init__(self, evaluator, parent_context, comp_for): - super(CompForContext, self).__init__(evaluator, parent_context) - self.tree_node = comp_for - - def get_node(self): - return self.tree_node - - def get_filters(self, search_global, until_position=None, origin_scope=None): - yield ParserTreeFilter(self.evaluator, self) - - -class Comprehension(AbstractIterable): - @staticmethod - def from_atom(evaluator, context, atom): - bracket = atom.children[0] - if bracket == '{': - if atom.children[1].children[1] == ':': - cls = DictComprehension - else: - cls = SetComprehension - elif bracket == '(': - cls = GeneratorComprehension - elif bracket == '[': - cls = ListComprehension - return cls(evaluator, context, atom) - - def __init__(self, evaluator, defining_context, atom): - super(Comprehension, self).__init__(evaluator) - self._defining_context = defining_context - self._atom = atom - - def _get_comprehension(self): - # The atom contains a testlist_comp - return self._atom.children[1] - - def _get_comp_for(self): - # The atom contains a testlist_comp - return self._get_comprehension().children[1] - - def _eval_node(self, index=0): - """ - The first part `x + 1` of the list comprehension: - - [x + 1 for x in foo] - """ - return self._get_comprehension().children[index] - - @evaluator_method_cache() - def _get_comp_for_context(self, parent_context, comp_for): - # TODO shouldn't this be part of create_context? - return CompForContext.from_comp_for(parent_context, comp_for) - - def _nested(self, comp_fors, parent_context=None): - comp_for = comp_fors[0] - input_node = comp_for.children[3] - parent_context = parent_context or self._defining_context - input_types = parent_context.eval_node(input_node) - - cn = ContextualizedNode(parent_context, input_node) - iterated = input_types.iterate(cn) - exprlist = comp_for.children[1] - for i, lazy_context in enumerate(iterated): - types = lazy_context.infer() - dct = unpack_tuple_to_dict(parent_context, types, exprlist) - context_ = self._get_comp_for_context( - parent_context, - comp_for, - ) - with predefine_names(context_, comp_for, dct): - try: - for result in self._nested(comp_fors[1:], context_): - yield result - except IndexError: - iterated = context_.eval_node(self._eval_node()) - if self.array_type == 'dict': - yield iterated, context_.eval_node(self._eval_node(2)) - else: - yield iterated - - @evaluator_method_cache(default=[]) - @to_list - def _iterate(self): - comp_fors = tuple(get_comp_fors(self._get_comp_for())) - for result in self._nested(comp_fors): - yield result - - def py__iter__(self): - for set_ in self._iterate(): - yield LazyKnownContexts(set_) - - def __repr__(self): - return "<%s of %s>" % (type(self).__name__, self._atom) - - -class ArrayMixin(object): - def get_filters(self, search_global, until_position=None, origin_scope=None): - # `array.type` is a string with the type, e.g. 'list'. - compiled_obj = compiled.builtin_from_name(self.evaluator, self.array_type) - yield SpecialMethodFilter(self, self.builtin_methods, compiled_obj) - for typ in compiled_obj.execute_evaluated(self): - for filter in typ.get_filters(): - yield filter - - def py__bool__(self): - return None # We don't know the length, because of appends. - - def py__class__(self): - return compiled.builtin_from_name(self.evaluator, self.array_type) - - @safe_property - def parent(self): - return self.evaluator.BUILTINS - - def dict_values(self): - return ContextSet.from_sets( - self._defining_context.eval_node(v) - for k, v in self._items() - ) - - -class ListComprehension(ArrayMixin, Comprehension): - array_type = 'list' - - def py__getitem__(self, index): - if isinstance(index, slice): - return ContextSet(self) - - all_types = list(self.py__iter__()) - return all_types[index].infer() - - -class SetComprehension(ArrayMixin, Comprehension): - array_type = 'set' - - -@has_builtin_methods -class DictComprehension(ArrayMixin, Comprehension): - array_type = 'dict' - - def _get_comp_for(self): - return self._get_comprehension().children[3] - - def py__iter__(self): - for keys, values in self._iterate(): - yield LazyKnownContexts(keys) - - def py__getitem__(self, index): - for keys, values in self._iterate(): - for k in keys: - if isinstance(k, compiled.CompiledObject): - if k.obj == index: - return values - return self.dict_values() - - def dict_values(self): - return ContextSet.from_sets(values for keys, values in self._iterate()) - - @register_builtin_method('values') - def _imitate_values(self): - lazy_context = LazyKnownContexts(self.dict_values()) - return ContextSet(FakeSequence(self.evaluator, 'list', [lazy_context])) - - @register_builtin_method('items') - def _imitate_items(self): - items = ContextSet.from_iterable( - FakeSequence( - self.evaluator, 'tuple' - (LazyKnownContexts(keys), LazyKnownContexts(values)) - ) for keys, values in self._iterate() - ) - - return create_evaluated_sequence_set(self.evaluator, items, sequence_type='list') - - -class GeneratorComprehension(GeneratorMixin, Comprehension): - pass - - -class SequenceLiteralContext(ArrayMixin, AbstractIterable): - mapping = {'(': 'tuple', - '[': 'list', - '{': 'set'} - - def __init__(self, evaluator, defining_context, atom): - super(SequenceLiteralContext, self).__init__(evaluator) - self.atom = atom - self._defining_context = defining_context - - if self.atom.type in ('testlist_star_expr', 'testlist'): - self.array_type = 'tuple' - else: - self.array_type = SequenceLiteralContext.mapping[atom.children[0]] - """The builtin name of the array (list, set, tuple or dict).""" - - def py__getitem__(self, index): - """Here the index is an int/str. Raises IndexError/KeyError.""" - if self.array_type == 'dict': - for key, value in self._items(): - for k in self._defining_context.eval_node(key): - if isinstance(k, compiled.CompiledObject) \ - and index == k.obj: - return self._defining_context.eval_node(value) - raise KeyError('No key found in dictionary %s.' % self) - - # Can raise an IndexError - if isinstance(index, slice): - return ContextSet(self) - else: - return self._defining_context.eval_node(self._items()[index]) - - def py__iter__(self): - """ - While values returns the possible values for any array field, this - function returns the value for a certain index. - """ - if self.array_type == 'dict': - # Get keys. - types = ContextSet() - for k, _ in self._items(): - types |= self._defining_context.eval_node(k) - # We don't know which dict index comes first, therefore always - # yield all the types. - for _ in types: - yield LazyKnownContexts(types) - else: - for node in self._items(): - yield LazyTreeContext(self._defining_context, node) - - for addition in check_array_additions(self._defining_context, self): - yield addition - - def _values(self): - """Returns a list of a list of node.""" - if self.array_type == 'dict': - return ContextSet.from_sets(v for k, v in self._items()) - else: - return self._items() - - def _items(self): - c = self.atom.children - - if self.atom.type in ('testlist_star_expr', 'testlist'): - return c[::2] - - array_node = c[1] - if array_node in (']', '}', ')'): - return [] # Direct closing bracket, doesn't contain items. - - if array_node.type == 'testlist_comp': - return array_node.children[::2] - elif array_node.type == 'dictorsetmaker': - kv = [] - iterator = iter(array_node.children) - for key in iterator: - op = next(iterator, None) - if op is None or op == ',': - kv.append(key) # A set. - else: - assert op == ':' # A dict. - kv.append((key, next(iterator))) - next(iterator, None) # Possible comma. - return kv - else: - return [array_node] - - def exact_key_items(self): - """ - Returns a generator of tuples like dict.items(), where the key is - resolved (as a string) and the values are still lazy contexts. - """ - for key_node, value in self._items(): - for key in self._defining_context.eval_node(key_node): - if is_string(key): - yield key.obj, LazyTreeContext(self._defining_context, value) - - def __repr__(self): - return "<%s of %s>" % (self.__class__.__name__, self.atom) - - -@has_builtin_methods -class DictLiteralContext(SequenceLiteralContext): - array_type = 'dict' - - def __init__(self, evaluator, defining_context, atom): - super(SequenceLiteralContext, self).__init__(evaluator) - self._defining_context = defining_context - self.atom = atom - - @register_builtin_method('values') - def _imitate_values(self): - lazy_context = LazyKnownContexts(self.dict_values()) - return ContextSet(FakeSequence(self.evaluator, 'list', [lazy_context])) - - @register_builtin_method('items') - def _imitate_items(self): - lazy_contexts = [ - LazyKnownContext(FakeSequence( - self.evaluator, 'tuple', - (LazyTreeContext(self._defining_context, key_node), - LazyTreeContext(self._defining_context, value_node)) - )) for key_node, value_node in self._items() - ] - - return ContextSet(FakeSequence(self.evaluator, 'list', lazy_contexts)) - - -class _FakeArray(SequenceLiteralContext): - def __init__(self, evaluator, container, type): - super(SequenceLiteralContext, self).__init__(evaluator) - self.array_type = type - self.atom = container - # TODO is this class really needed? - - -class FakeSequence(_FakeArray): - def __init__(self, evaluator, array_type, lazy_context_list): - """ - type should be one of "tuple", "list" - """ - super(FakeSequence, self).__init__(evaluator, None, array_type) - self._lazy_context_list = lazy_context_list - - def py__getitem__(self, index): - return self._lazy_context_list[index].infer() - - def py__iter__(self): - return self._lazy_context_list - - def py__bool__(self): - return bool(len(self._lazy_context_list)) - - def __repr__(self): - return "<%s of %s>" % (type(self).__name__, self._lazy_context_list) - - -class FakeDict(_FakeArray): - def __init__(self, evaluator, dct): - super(FakeDict, self).__init__(evaluator, dct, 'dict') - self._dct = dct - - def py__iter__(self): - for key in self._dct: - yield LazyKnownContext(compiled.create(self.evaluator, key)) - - def py__getitem__(self, index): - return self._dct[index].infer() - - def dict_values(self): - return ContextSet.from_sets(lazy_context.infer() for lazy_context in self._dct.values()) - - def exact_key_items(self): - return self._dct.items() - - -class MergedArray(_FakeArray): - def __init__(self, evaluator, arrays): - super(MergedArray, self).__init__(evaluator, arrays, arrays[-1].array_type) - self._arrays = arrays - - def py__iter__(self): - for array in self._arrays: - for lazy_context in array.py__iter__(): - yield lazy_context - - def py__getitem__(self, index): - return ContextSet.from_sets(lazy_context.infer() for lazy_context in self.py__iter__()) - - def _items(self): - for array in self._arrays: - for a in array._items(): - yield a - - def __len__(self): - return sum(len(a) for a in self._arrays) - - -def unpack_tuple_to_dict(context, types, exprlist): - """ - Unpacking tuple assignments in for statements and expr_stmts. - """ - if exprlist.type == 'name': - return {exprlist.value: types} - elif exprlist.type == 'atom' and exprlist.children[0] in '([': - return unpack_tuple_to_dict(context, types, exprlist.children[1]) - elif exprlist.type in ('testlist', 'testlist_comp', 'exprlist', - 'testlist_star_expr'): - dct = {} - parts = iter(exprlist.children[::2]) - n = 0 - for lazy_context in types.iterate(exprlist): - n += 1 - try: - part = next(parts) - except StopIteration: - # TODO this context is probably not right. - analysis.add(context, 'value-error-too-many-values', part, - message="ValueError: too many values to unpack (expected %s)" % n) - else: - dct.update(unpack_tuple_to_dict(context, lazy_context.infer(), part)) - has_parts = next(parts, None) - if types and has_parts is not None: - # TODO this context is probably not right. - analysis.add(context, 'value-error-too-few-values', has_parts, - message="ValueError: need more than %s values to unpack" % n) - return dct - elif exprlist.type == 'power' or exprlist.type == 'atom_expr': - # Something like ``arr[x], var = ...``. - # This is something that is not yet supported, would also be difficult - # to write into a dict. - return {} - elif exprlist.type == 'star_expr': # `a, *b, c = x` type unpackings - # Currently we're not supporting them. - return {} - raise NotImplementedError - - -def check_array_additions(context, sequence): - """ Just a mapper function for the internal _check_array_additions """ - if sequence.array_type not in ('list', 'set'): - # TODO also check for dict updates - return NO_CONTEXTS - - return _check_array_additions(context, sequence) - - -@evaluator_method_cache(default=NO_CONTEXTS) -@debug.increase_indent -def _check_array_additions(context, sequence): - """ - Checks if a `Array` has "add" (append, insert, extend) statements: - - >>> a = [""] - >>> a.append(1) - """ - from jedi.evaluate import arguments - - debug.dbg('Dynamic array search for %s' % sequence, color='MAGENTA') - module_context = context.get_root_context() - if not settings.dynamic_array_additions or isinstance(module_context, compiled.CompiledObject): - debug.dbg('Dynamic array search aborted.', color='MAGENTA') - return ContextSet() - - def find_additions(context, arglist, add_name): - params = list(arguments.TreeArguments(context.evaluator, context, arglist).unpack()) - result = set() - if add_name in ['insert']: - params = params[1:] - if add_name in ['append', 'add', 'insert']: - for key, whatever in params: - result.add(whatever) - elif add_name in ['extend', 'update']: - for key, lazy_context in params: - result |= set(lazy_context.infer().iterate()) - return result - - temp_param_add, settings.dynamic_params_for_other_modules = \ - settings.dynamic_params_for_other_modules, False - - is_list = sequence.name.string_name == 'list' - search_names = (['append', 'extend', 'insert'] if is_list else ['add', 'update']) - - added_types = set() - for add_name in search_names: - try: - possible_names = module_context.tree_node.get_used_names()[add_name] - except KeyError: - continue - else: - for name in possible_names: - context_node = context.tree_node - if not (context_node.start_pos < name.start_pos < context_node.end_pos): - continue - trailer = name.parent - power = trailer.parent - trailer_pos = power.children.index(trailer) - try: - execution_trailer = power.children[trailer_pos + 1] - except IndexError: - continue - else: - if execution_trailer.type != 'trailer' \ - or execution_trailer.children[0] != '(' \ - or execution_trailer.children[1] == ')': - continue - - random_context = context.create_context(name) - - with recursion.execution_allowed(context.evaluator, power) as allowed: - if allowed: - found = evaluate_call_of_leaf( - random_context, - name, - cut_own_trailer=True - ) - if sequence in found: - # The arrays match. Now add the results - added_types |= find_additions( - random_context, - execution_trailer.children[1], - add_name - ) - - # reset settings - settings.dynamic_params_for_other_modules = temp_param_add - debug.dbg('Dynamic array result %s' % added_types, color='MAGENTA') - return added_types - - -def get_dynamic_array_instance(instance): - """Used for set() and list() instances.""" - if not settings.dynamic_array_additions: - return instance.var_args - - ai = _ArrayInstance(instance) - from jedi.evaluate import arguments - return arguments.ValuesArguments([ContextSet(ai)]) - - -class _ArrayInstance(object): - """ - Used for the usage of set() and list(). - This is definitely a hack, but a good one :-) - It makes it possible to use set/list conversions. - - In contrast to Array, ListComprehension and all other iterable types, this - is something that is only used inside `evaluate/compiled/fake/builtins.py` - and therefore doesn't need filters, `py__bool__` and so on, because - we don't use these operations in `builtins.py`. - """ - def __init__(self, instance): - self.instance = instance - self.var_args = instance.var_args - - def py__iter__(self): - var_args = self.var_args - try: - _, lazy_context = next(var_args.unpack()) - except StopIteration: - pass - else: - for lazy in lazy_context.infer().iterate(): - yield lazy - - from jedi.evaluate import arguments - if isinstance(var_args, arguments.TreeArguments): - additions = _check_array_additions(var_args.context, self.instance) - for addition in additions: - yield addition - - def iterate(self, contextualized_node=None): - return self.py__iter__() - - -class Slice(Context): - def __init__(self, context, start, stop, step): - super(Slice, self).__init__( - context.evaluator, - parent_context=context.evaluator.BUILTINS - ) - self._context = context - # all of them are either a Precedence or None. - self._start = start - self._stop = stop - self._step = step - - @property - def obj(self): - """ - Imitate CompiledObject.obj behavior and return a ``builtin.slice()`` - object. - """ - def get(element): - if element is None: - return None - - result = self._context.eval_node(element) - if len(result) != 1: - # For simplicity, we want slices to be clear defined with just - # one type. Otherwise we will return an empty slice object. - raise IndexError - try: - return list(result)[0].obj - except AttributeError: - return None - - try: - return slice(get(self._start), get(self._stop), get(self._step)) - except IndexError: - return slice(None, None, None) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/klass.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/klass.py deleted file mode 100644 index b7d61d3..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/klass.py +++ /dev/null @@ -1,197 +0,0 @@ -""" -Like described in the :mod:`parso.python.tree` module, -there's a need for an ast like module to represent the states of parsed -modules. - -But now there are also structures in Python that need a little bit more than -that. An ``Instance`` for example is only a ``Class`` before it is -instantiated. This class represents these cases. - -So, why is there also a ``Class`` class here? Well, there are decorators and -they change classes in Python 3. - -Representation modules also define "magic methods". Those methods look like -``py__foo__`` and are typically mappable to the Python equivalents ``__call__`` -and others. Here's a list: - -====================================== ======================================== -**Method** **Description** --------------------------------------- ---------------------------------------- -py__call__(params: Array) On callable objects, returns types. -py__bool__() Returns True/False/None; None means that - there's no certainty. -py__bases__() Returns a list of base classes. -py__mro__() Returns a list of classes (the mro). -py__iter__() Returns a generator of a set of types. -py__class__() Returns the class of an instance. -py__getitem__(index: int/str) Returns a a set of types of the index. - Can raise an IndexError/KeyError. -py__file__() Only on modules. Returns None if does - not exist. -py__package__() Only on modules. For the import system. -py__path__() Only on modules. For the import system. -py__get__(call_object) Only on instances. Simulates - descriptors. -py__doc__(include_call_signature: Returns the docstring for a context. - bool) -====================================== ======================================== - -""" -from jedi._compatibility import use_metaclass -from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass -from jedi.evaluate import compiled -from jedi.evaluate.lazy_context import LazyKnownContext -from jedi.evaluate.filters import ParserTreeFilter, TreeNameDefinition, \ - ContextName, AnonymousInstanceParamName -from jedi.evaluate.base_context import ContextSet, iterator_to_context_set, \ - TreeContext - - -def apply_py__get__(context, base_context): - try: - method = context.py__get__ - except AttributeError: - yield context - else: - for descriptor_context in method(base_context): - yield descriptor_context - - -class ClassName(TreeNameDefinition): - def __init__(self, parent_context, tree_name, name_context): - super(ClassName, self).__init__(parent_context, tree_name) - self._name_context = name_context - - @iterator_to_context_set - def infer(self): - # TODO this _name_to_types might get refactored and be a part of the - # parent class. Once it is, we can probably just overwrite method to - # achieve this. - from jedi.evaluate.syntax_tree import tree_name_to_contexts - inferred = tree_name_to_contexts( - self.parent_context.evaluator, self._name_context, self.tree_name) - - for result_context in inferred: - for c in apply_py__get__(result_context, self.parent_context): - yield c - - -class ClassFilter(ParserTreeFilter): - name_class = ClassName - - def _convert_names(self, names): - return [self.name_class(self.context, name, self._node_context) - for name in names] - - -class ClassContext(use_metaclass(CachedMetaClass, TreeContext)): - """ - This class is not only important to extend `tree.Class`, it is also a - important for descriptors (if the descriptor methods are evaluated or not). - """ - api_type = 'class' - - def __init__(self, evaluator, parent_context, classdef): - super(ClassContext, self).__init__(evaluator, parent_context=parent_context) - self.tree_node = classdef - - @evaluator_method_cache(default=()) - def py__mro__(self): - def add(cls): - if cls not in mro: - mro.append(cls) - - mro = [self] - # TODO Do a proper mro resolution. Currently we are just listing - # classes. However, it's a complicated algorithm. - for lazy_cls in self.py__bases__(): - # TODO there's multiple different mro paths possible if this yields - # multiple possibilities. Could be changed to be more correct. - for cls in lazy_cls.infer(): - # TODO detect for TypeError: duplicate base class str, - # e.g. `class X(str, str): pass` - try: - mro_method = cls.py__mro__ - except AttributeError: - # TODO add a TypeError like: - """ - >>> class Y(lambda: test): pass - Traceback (most recent call last): - File "", line 1, in - TypeError: function() argument 1 must be code, not str - >>> class Y(1): pass - Traceback (most recent call last): - File "", line 1, in - TypeError: int() takes at most 2 arguments (3 given) - """ - pass - else: - add(cls) - for cls_new in mro_method(): - add(cls_new) - return tuple(mro) - - @evaluator_method_cache(default=()) - def py__bases__(self): - arglist = self.tree_node.get_super_arglist() - if arglist: - from jedi.evaluate import arguments - args = arguments.TreeArguments(self.evaluator, self, arglist) - return [value for key, value in args.unpack() if key is None] - else: - return [LazyKnownContext(compiled.create(self.evaluator, object))] - - def py__call__(self, params): - from jedi.evaluate.context import TreeInstance - return ContextSet(TreeInstance(self.evaluator, self.parent_context, self, params)) - - def py__class__(self): - return compiled.create(self.evaluator, type) - - def get_params(self): - from jedi.evaluate.context import AnonymousInstance - anon = AnonymousInstance(self.evaluator, self.parent_context, self) - return [AnonymousInstanceParamName(anon, param.name) for param in self.funcdef.get_params()] - - def get_filters(self, search_global, until_position=None, origin_scope=None, is_instance=False): - if search_global: - yield ParserTreeFilter( - self.evaluator, - context=self, - until_position=until_position, - origin_scope=origin_scope - ) - else: - for cls in self.py__mro__(): - if isinstance(cls, compiled.CompiledObject): - for filter in cls.get_filters(is_instance=is_instance): - yield filter - else: - yield ClassFilter( - self.evaluator, self, node_context=cls, - origin_scope=origin_scope) - - def is_class(self): - return True - - def get_function_slot_names(self, name): - for filter in self.get_filters(search_global=False): - names = filter.get(name) - if names: - return names - return [] - - def get_param_names(self): - for name in self.get_function_slot_names('__init__'): - for context_ in name.infer(): - try: - method = context_.get_param_names - except AttributeError: - pass - else: - return list(method())[1:] - return [] - - @property - def name(self): - return ContextName(self, self.tree_node.name) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/module.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/module.py deleted file mode 100644 index 5ba92cd..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/module.py +++ /dev/null @@ -1,213 +0,0 @@ -import pkgutil -import imp -import re -import os - -from parso import python_bytes_to_unicode - -from jedi._compatibility import use_metaclass -from jedi.evaluate.cache import CachedMetaClass, evaluator_method_cache -from jedi.evaluate.filters import GlobalNameFilter, ContextNameMixin, \ - AbstractNameDefinition, ParserTreeFilter, DictFilter -from jedi.evaluate import compiled -from jedi.evaluate.base_context import TreeContext -from jedi.evaluate.imports import SubModuleName, infer_import - - -class _ModuleAttributeName(AbstractNameDefinition): - """ - For module attributes like __file__, __str__ and so on. - """ - api_type = 'instance' - - def __init__(self, parent_module, string_name): - self.parent_context = parent_module - self.string_name = string_name - - def infer(self): - return compiled.create(self.parent_context.evaluator, str).execute_evaluated() - - -class ModuleName(ContextNameMixin, AbstractNameDefinition): - start_pos = 1, 0 - - def __init__(self, context, name): - self._context = context - self._name = name - - @property - def string_name(self): - return self._name - - -class ModuleContext(use_metaclass(CachedMetaClass, TreeContext)): - api_type = 'module' - parent_context = None - - def __init__(self, evaluator, module_node, path): - super(ModuleContext, self).__init__(evaluator, parent_context=None) - self.tree_node = module_node - self._path = path - - def get_filters(self, search_global, until_position=None, origin_scope=None): - yield ParserTreeFilter( - self.evaluator, - context=self, - until_position=until_position, - origin_scope=origin_scope - ) - yield GlobalNameFilter(self, self.tree_node) - yield DictFilter(self._sub_modules_dict()) - yield DictFilter(self._module_attributes_dict()) - for star_module in self.star_imports(): - yield next(star_module.get_filters(search_global)) - - # I'm not sure if the star import cache is really that effective anymore - # with all the other really fast import caches. Recheck. Also we would need - # to push the star imports into Evaluator.modules, if we reenable this. - @evaluator_method_cache([]) - def star_imports(self): - modules = [] - for i in self.tree_node.iter_imports(): - if i.is_star_import(): - name = i.get_paths()[-1][-1] - new = infer_import(self, name) - for module in new: - if isinstance(module, ModuleContext): - modules += module.star_imports() - modules += new - return modules - - @evaluator_method_cache() - def _module_attributes_dict(self): - names = ['__file__', '__package__', '__doc__', '__name__'] - # All the additional module attributes are strings. - return dict((n, _ModuleAttributeName(self, n)) for n in names) - - @property - def _string_name(self): - """ This is used for the goto functions. """ - if self._path is None: - return '' # no path -> empty name - else: - sep = (re.escape(os.path.sep),) * 2 - r = re.search(r'([^%s]*?)(%s__init__)?(\.py|\.so)?$' % sep, self._path) - # Remove PEP 3149 names - return re.sub('\.[a-z]+-\d{2}[mud]{0,3}$', '', r.group(1)) - - @property - @evaluator_method_cache() - def name(self): - return ModuleName(self, self._string_name) - - def _get_init_directory(self): - """ - :return: The path to the directory of a package. None in case it's not - a package. - """ - for suffix, _, _ in imp.get_suffixes(): - ending = '__init__' + suffix - py__file__ = self.py__file__() - if py__file__ is not None and py__file__.endswith(ending): - # Remove the ending, including the separator. - return self.py__file__()[:-len(ending) - 1] - return None - - def py__name__(self): - for name, module in self.evaluator.modules.items(): - if module == self and name != '': - return name - - return '__main__' - - def py__file__(self): - """ - In contrast to Python's __file__ can be None. - """ - if self._path is None: - return None - - return os.path.abspath(self._path) - - def py__package__(self): - if self._get_init_directory() is None: - return re.sub(r'\.?[^\.]+$', '', self.py__name__()) - else: - return self.py__name__() - - def _py__path__(self): - search_path = self.evaluator.project.sys_path - init_path = self.py__file__() - if os.path.basename(init_path) == '__init__.py': - with open(init_path, 'rb') as f: - content = python_bytes_to_unicode(f.read(), errors='replace') - # these are strings that need to be used for namespace packages, - # the first one is ``pkgutil``, the second ``pkg_resources``. - options = ('declare_namespace(__name__)', 'extend_path(__path__') - if options[0] in content or options[1] in content: - # It is a namespace, now try to find the rest of the - # modules on sys_path or whatever the search_path is. - paths = set() - for s in search_path: - other = os.path.join(s, self.name.string_name) - if os.path.isdir(other): - paths.add(other) - if paths: - return list(paths) - # TODO I'm not sure if this is how nested namespace - # packages work. The tests are not really good enough to - # show that. - # Default to this. - return [self._get_init_directory()] - - @property - def py__path__(self): - """ - Not seen here, since it's a property. The callback actually uses a - variable, so use it like:: - - foo.py__path__(sys_path) - - In case of a package, this returns Python's __path__ attribute, which - is a list of paths (strings). - Raises an AttributeError if the module is not a package. - """ - path = self._get_init_directory() - - if path is None: - raise AttributeError('Only packages have __path__ attributes.') - else: - return self._py__path__ - - @evaluator_method_cache() - def _sub_modules_dict(self): - """ - Lists modules in the directory of this module (if this module is a - package). - """ - path = self._path - names = {} - if path is not None and path.endswith(os.path.sep + '__init__.py'): - mods = pkgutil.iter_modules([os.path.dirname(path)]) - for module_loader, name, is_pkg in mods: - # It's obviously a relative import to the current module. - names[name] = SubModuleName(self, name) - - # TODO add something like this in the future, its cleaner than the - # import hacks. - # ``os.path`` is a hardcoded exception, because it's a - # ``sys.modules`` modification. - # if str(self.name) == 'os': - # names.append(Name('path', parent_context=self)) - - return names - - def py__class__(self): - return compiled.get_special_object(self.evaluator, 'MODULE_CLASS') - - def __repr__(self): - return "<%s: %s@%s-%s>" % ( - self.__class__.__name__, self._string_name, - self.tree_node.start_pos[0], self.tree_node.end_pos[0]) - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/namespace.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/namespace.py deleted file mode 100644 index e40c23a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/context/namespace.py +++ /dev/null @@ -1,74 +0,0 @@ -import os -from itertools import chain - -from jedi._compatibility import use_metaclass -from jedi.evaluate.cache import evaluator_method_cache, CachedMetaClass -from jedi.evaluate import imports -from jedi.evaluate.filters import DictFilter, AbstractNameDefinition -from jedi.evaluate.base_context import NO_CONTEXTS, TreeContext - - -class ImplicitNSName(AbstractNameDefinition): - """ - Accessing names for implicit namespace packages should infer to nothing. - This object will prevent Jedi from raising exceptions - """ - def __init__(self, implicit_ns_context, string_name): - self.implicit_ns_context = implicit_ns_context - self.string_name = string_name - - def infer(self): - return NO_CONTEXTS - - def get_root_context(self): - return self.implicit_ns_context - - -class ImplicitNamespaceContext(use_metaclass(CachedMetaClass, TreeContext)): - """ - Provides support for implicit namespace packages - """ - api_type = 'module' - parent_context = None - - def __init__(self, evaluator, fullname): - super(ImplicitNamespaceContext, self).__init__(evaluator, parent_context=None) - self.evaluator = evaluator - self.fullname = fullname - - def get_filters(self, search_global, until_position=None, origin_scope=None): - yield DictFilter(self._sub_modules_dict()) - - @property - @evaluator_method_cache() - def name(self): - string_name = self.py__package__().rpartition('.')[-1] - return ImplicitNSName(self, string_name) - - def py__file__(self): - return None - - def py__package__(self): - """Return the fullname - """ - return self.fullname - - @property - def py__path__(self): - return lambda: [self.paths] - - @evaluator_method_cache() - def _sub_modules_dict(self): - names = {} - - paths = self.paths - file_names = chain.from_iterable(os.listdir(path) for path in paths) - mods = [ - file_name.rpartition('.')[0] if '.' in file_name else file_name - for file_name in file_names - if file_name != '__pycache__' - ] - - for name in mods: - names[name] = imports.SubModuleName(self, name) - return names diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/docstrings.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/docstrings.py deleted file mode 100644 index f9c1141..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/docstrings.py +++ /dev/null @@ -1,289 +0,0 @@ -""" -Docstrings are another source of information for functions and classes. -:mod:`jedi.evaluate.dynamic` tries to find all executions of functions, while -the docstring parsing is much easier. There are three different types of -docstrings that |jedi| understands: - -- `Sphinx `_ -- `Epydoc `_ -- `Numpydoc `_ - -For example, the sphinx annotation ``:type foo: str`` clearly states that the -type of ``foo`` is ``str``. - -As an addition to parameter searching, this module also provides return -annotations. -""" - -import re -from textwrap import dedent - -from parso import parse - -from jedi._compatibility import u -from jedi.evaluate.utils import indent_block -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.base_context import iterator_to_context_set, ContextSet, \ - NO_CONTEXTS -from jedi.evaluate.lazy_context import LazyKnownContexts - - -DOCSTRING_PARAM_PATTERNS = [ - r'\s*:type\s+%s:\s*([^\n]+)', # Sphinx - r'\s*:param\s+(\w+)\s+%s:[^\n]*', # Sphinx param with type - r'\s*@type\s+%s:\s*([^\n]+)', # Epydoc -] - -DOCSTRING_RETURN_PATTERNS = [ - re.compile(r'\s*:rtype:\s*([^\n]+)', re.M), # Sphinx - re.compile(r'\s*@rtype:\s*([^\n]+)', re.M), # Epydoc -] - -REST_ROLE_PATTERN = re.compile(r':[^`]+:`([^`]+)`') - - -try: - from numpydoc.docscrape import NumpyDocString -except ImportError: - def _search_param_in_numpydocstr(docstr, param_str): - return [] - - def _search_return_in_numpydocstr(docstr): - return [] -else: - def _search_param_in_numpydocstr(docstr, param_str): - """Search `docstr` (in numpydoc format) for type(-s) of `param_str`.""" - try: - # This is a non-public API. If it ever changes we should be - # prepared and return gracefully. - params = NumpyDocString(docstr)._parsed_data['Parameters'] - except (KeyError, AttributeError): - return [] - for p_name, p_type, p_descr in params: - if p_name == param_str: - m = re.match('([^,]+(,[^,]+)*?)(,[ ]*optional)?$', p_type) - if m: - p_type = m.group(1) - return list(_expand_typestr(p_type)) - return [] - - def _search_return_in_numpydocstr(docstr): - """ - Search `docstr` (in numpydoc format) for type(-s) of function returns. - """ - doc = NumpyDocString(docstr) - try: - # This is a non-public API. If it ever changes we should be - # prepared and return gracefully. - returns = doc._parsed_data['Returns'] - returns += doc._parsed_data['Yields'] - except (KeyError, AttributeError): - raise StopIteration - for r_name, r_type, r_descr in returns: - #Return names are optional and if so the type is in the name - if not r_type: - r_type = r_name - for type_ in _expand_typestr(r_type): - yield type_ - - -def _expand_typestr(type_str): - """ - Attempts to interpret the possible types in `type_str` - """ - # Check if alternative types are specified with 'or' - if re.search('\\bor\\b', type_str): - for t in type_str.split('or'): - yield t.split('of')[0].strip() - # Check if like "list of `type`" and set type to list - elif re.search('\\bof\\b', type_str): - yield type_str.split('of')[0] - # Check if type has is a set of valid literal values eg: {'C', 'F', 'A'} - elif type_str.startswith('{'): - node = parse(type_str, version='3.6').children[0] - if node.type == 'atom': - for leaf in node.children[1].children: - if leaf.type == 'number': - if '.' in leaf.value: - yield 'float' - else: - yield 'int' - elif leaf.type == 'string': - if 'b' in leaf.string_prefix.lower(): - yield 'bytes' - else: - yield 'str' - # Ignore everything else. - - # Otherwise just work with what we have. - else: - yield type_str - - -def _search_param_in_docstr(docstr, param_str): - """ - Search `docstr` for type(-s) of `param_str`. - - >>> _search_param_in_docstr(':type param: int', 'param') - ['int'] - >>> _search_param_in_docstr('@type param: int', 'param') - ['int'] - >>> _search_param_in_docstr( - ... ':type param: :class:`threading.Thread`', 'param') - ['threading.Thread'] - >>> bool(_search_param_in_docstr('no document', 'param')) - False - >>> _search_param_in_docstr(':param int param: some description', 'param') - ['int'] - - """ - # look at #40 to see definitions of those params - patterns = [re.compile(p % re.escape(param_str)) - for p in DOCSTRING_PARAM_PATTERNS] - for pattern in patterns: - match = pattern.search(docstr) - if match: - return [_strip_rst_role(match.group(1))] - - return (_search_param_in_numpydocstr(docstr, param_str) or - []) - - -def _strip_rst_role(type_str): - """ - Strip off the part looks like a ReST role in `type_str`. - - >>> _strip_rst_role(':class:`ClassName`') # strip off :class: - 'ClassName' - >>> _strip_rst_role(':py:obj:`module.Object`') # works with domain - 'module.Object' - >>> _strip_rst_role('ClassName') # do nothing when not ReST role - 'ClassName' - - See also: - http://sphinx-doc.org/domains.html#cross-referencing-python-objects - - """ - match = REST_ROLE_PATTERN.match(type_str) - if match: - return match.group(1) - else: - return type_str - - -def _evaluate_for_statement_string(module_context, string): - code = dedent(u(""" - def pseudo_docstring_stuff(): - ''' - Create a pseudo function for docstring statements. - Need this docstring so that if the below part is not valid Python this - is still a function. - ''' - {0} - """)) - if string is None: - return [] - - for element in re.findall('((?:\w+\.)*\w+)\.', string): - # Try to import module part in dotted name. - # (e.g., 'threading' in 'threading.Thread'). - string = 'import %s\n' % element + string - - # Take the default grammar here, if we load the Python 2.7 grammar here, it - # will be impossible to use `...` (Ellipsis) as a token. Docstring types - # don't need to conform with the current grammar. - grammar = module_context.evaluator.latest_grammar - module = grammar.parse(code.format(indent_block(string))) - try: - funcdef = next(module.iter_funcdefs()) - # First pick suite, then simple_stmt and then the node, - # which is also not the last item, because there's a newline. - stmt = funcdef.children[-1].children[-1].children[-2] - except (AttributeError, IndexError): - return [] - - from jedi.evaluate.context import FunctionContext - function_context = FunctionContext( - module_context.evaluator, - module_context, - funcdef - ) - func_execution_context = function_context.get_function_execution() - # Use the module of the param. - # TODO this module is not the module of the param in case of a function - # call. In that case it's the module of the function call. - # stuffed with content from a function call. - return list(_execute_types_in_stmt(func_execution_context, stmt)) - - -def _execute_types_in_stmt(module_context, stmt): - """ - Executing all types or general elements that we find in a statement. This - doesn't include tuple, list and dict literals, because the stuff they - contain is executed. (Used as type information). - """ - definitions = module_context.eval_node(stmt) - return ContextSet.from_sets( - _execute_array_values(module_context.evaluator, d) - for d in definitions - ) - - -def _execute_array_values(evaluator, array): - """ - Tuples indicate that there's not just one return value, but the listed - ones. `(str, int)` means that it returns a tuple with both types. - """ - from jedi.evaluate.context.iterable import SequenceLiteralContext, FakeSequence - if isinstance(array, SequenceLiteralContext): - values = [] - for lazy_context in array.py__iter__(): - objects = ContextSet.from_sets( - _execute_array_values(evaluator, typ) - for typ in lazy_context.infer() - ) - values.append(LazyKnownContexts(objects)) - return set([FakeSequence(evaluator, array.array_type, values)]) - else: - return array.execute_evaluated() - - -@evaluator_method_cache() -def infer_param(execution_context, param): - from jedi.evaluate.context.instance import AnonymousInstanceFunctionExecution - - def eval_docstring(docstring): - return ContextSet.from_iterable( - p - for param_str in _search_param_in_docstr(docstring, param.name.value) - for p in _evaluate_for_statement_string(module_context, param_str) - ) - module_context = execution_context.get_root_context() - func = param.get_parent_function() - if func.type == 'lambdef': - return NO_CONTEXTS - - types = eval_docstring(execution_context.py__doc__()) - if isinstance(execution_context, AnonymousInstanceFunctionExecution) and \ - execution_context.function_context.name.string_name == '__init__': - class_context = execution_context.instance.class_context - types |= eval_docstring(class_context.py__doc__()) - - return types - - -@evaluator_method_cache() -@iterator_to_context_set -def infer_return_types(function_context): - def search_return_in_docstr(code): - for p in DOCSTRING_RETURN_PATTERNS: - match = p.search(code) - if match: - yield _strip_rst_role(match.group(1)) - # Check for numpy style return hint - for type_ in _search_return_in_numpydocstr(code): - yield type_ - - for type_str in search_return_in_docstr(function_context.py__doc__()): - for type_eval in _evaluate_for_statement_string(function_context.get_root_context(), type_str): - yield type_eval diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/dynamic.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/dynamic.py deleted file mode 100644 index 7d05000..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/dynamic.py +++ /dev/null @@ -1,203 +0,0 @@ -""" -One of the really important features of |jedi| is to have an option to -understand code like this:: - - def foo(bar): - bar. # completion here - foo(1) - -There's no doubt wheter bar is an ``int`` or not, but if there's also a call -like ``foo('str')``, what would happen? Well, we'll just show both. Because -that's what a human would expect. - -It works as follows: - -- |Jedi| sees a param -- search for function calls named ``foo`` -- execute these calls and check the input. -""" - -from parso.python import tree -from jedi import settings -from jedi import debug -from jedi.evaluate.cache import evaluator_function_cache -from jedi.evaluate import imports -from jedi.evaluate.arguments import TreeArguments -from jedi.evaluate.param import create_default_params -from jedi.evaluate.helpers import is_stdlib_path -from jedi.evaluate.utils import to_list -from jedi.parser_utils import get_parent_scope -from jedi.evaluate.context import ModuleContext, instance -from jedi.evaluate.base_context import ContextSet - - - -MAX_PARAM_SEARCHES = 20 - - -class MergedExecutedParams(object): - """ - Simulates being a parameter while actually just being multiple params. - """ - def __init__(self, executed_params): - self._executed_params = executed_params - - def infer(self): - return ContextSet.from_sets(p.infer() for p in self._executed_params) - - -@debug.increase_indent -def search_params(evaluator, execution_context, funcdef): - """ - A dynamic search for param values. If you try to complete a type: - - >>> def func(foo): - ... foo - >>> func(1) - >>> func("") - - It is not known what the type ``foo`` without analysing the whole code. You - have to look for all calls to ``func`` to find out what ``foo`` possibly - is. - """ - if not settings.dynamic_params: - return create_default_params(execution_context, funcdef) - - evaluator.dynamic_params_depth += 1 - try: - path = execution_context.get_root_context().py__file__() - if path is not None and is_stdlib_path(path): - # We don't want to search for usages in the stdlib. Usually people - # don't work with it (except if you are a core maintainer, sorry). - # This makes everything slower. Just disable it and run the tests, - # you will see the slowdown, especially in 3.6. - return create_default_params(execution_context, funcdef) - - debug.dbg('Dynamic param search in %s.', funcdef.name.value, color='MAGENTA') - - module_context = execution_context.get_root_context() - function_executions = _search_function_executions( - evaluator, - module_context, - funcdef - ) - if function_executions: - zipped_params = zip(*list( - function_execution.get_params() - for function_execution in function_executions - )) - params = [MergedExecutedParams(executed_params) for executed_params in zipped_params] - # Evaluate the ExecutedParams to types. - else: - return create_default_params(execution_context, funcdef) - debug.dbg('Dynamic param result finished', color='MAGENTA') - return params - finally: - evaluator.dynamic_params_depth -= 1 - - -@evaluator_function_cache(default=None) -@to_list -def _search_function_executions(evaluator, module_context, funcdef): - """ - Returns a list of param names. - """ - func_string_name = funcdef.name.value - compare_node = funcdef - if func_string_name == '__init__': - cls = get_parent_scope(funcdef) - if isinstance(cls, tree.Class): - func_string_name = cls.name.value - compare_node = cls - - found_executions = False - i = 0 - for for_mod_context in imports.get_modules_containing_name( - evaluator, [module_context], func_string_name): - if not isinstance(module_context, ModuleContext): - return - for name, trailer in _get_possible_nodes(for_mod_context, func_string_name): - i += 1 - - # This is a simple way to stop Jedi's dynamic param recursion - # from going wild: The deeper Jedi's in the recursion, the less - # code should be evaluated. - if i * evaluator.dynamic_params_depth > MAX_PARAM_SEARCHES: - return - - random_context = evaluator.create_context(for_mod_context, name) - for function_execution in _check_name_for_execution( - evaluator, random_context, compare_node, name, trailer): - found_executions = True - yield function_execution - - # If there are results after processing a module, we're probably - # good to process. This is a speed optimization. - if found_executions: - return - - -def _get_possible_nodes(module_context, func_string_name): - try: - names = module_context.tree_node.get_used_names()[func_string_name] - except KeyError: - return - - for name in names: - bracket = name.get_next_leaf() - trailer = bracket.parent - if trailer.type == 'trailer' and bracket == '(': - yield name, trailer - - -def _check_name_for_execution(evaluator, context, compare_node, name, trailer): - from jedi.evaluate.context.function import FunctionExecutionContext - - def create_func_excs(): - arglist = trailer.children[1] - if arglist == ')': - arglist = () - args = TreeArguments(evaluator, context, arglist, trailer) - if value_node.type == 'funcdef': - yield value.get_function_execution(args) - else: - created_instance = instance.TreeInstance( - evaluator, - value.parent_context, - value, - args - ) - for execution in created_instance.create_init_executions(): - yield execution - - for value in evaluator.goto_definitions(context, name): - value_node = value.tree_node - if compare_node == value_node: - for func_execution in create_func_excs(): - yield func_execution - elif isinstance(value.parent_context, FunctionExecutionContext) and \ - compare_node.type == 'funcdef': - # Here we're trying to find decorators by checking the first - # parameter. It's not very generic though. Should find a better - # solution that also applies to nested decorators. - params = value.parent_context.get_params() - if len(params) != 1: - continue - values = params[0].infer() - nodes = [v.tree_node for v in values] - if nodes == [compare_node]: - # Found a decorator. - module_context = context.get_root_context() - execution_context = next(create_func_excs()) - for name, trailer in _get_possible_nodes(module_context, params[0].string_name): - if value_node.start_pos < name.start_pos < value_node.end_pos: - random_context = evaluator.create_context(execution_context, name) - iterator = _check_name_for_execution( - evaluator, - random_context, - compare_node, - name, - trailer - ) - for function_execution in iterator: - yield function_execution diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/filters.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/filters.py deleted file mode 100644 index 35dff9d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/filters.py +++ /dev/null @@ -1,434 +0,0 @@ -""" -Filters are objects that you can use to filter names in different scopes. They -are needed for name resolution. -""" -from abc import abstractmethod - -from parso.tree import search_ancestor - -from jedi._compatibility import is_py3 -from jedi.evaluate import flow_analysis -from jedi.evaluate.base_context import ContextSet, Context -from jedi.parser_utils import get_parent_scope -from jedi.evaluate.utils import to_list - - -class AbstractNameDefinition(object): - start_pos = None - string_name = None - parent_context = None - tree_name = None - - @abstractmethod - def infer(self): - raise NotImplementedError - - @abstractmethod - def goto(self): - # Typically names are already definitions and therefore a goto on that - # name will always result on itself. - return set([self]) - - def get_root_context(self): - return self.parent_context.get_root_context() - - def __repr__(self): - if self.start_pos is None: - return '<%s: %s>' % (self.__class__.__name__, self.string_name) - return '<%s: %s@%s>' % (self.__class__.__name__, self.string_name, self.start_pos) - - def execute(self, arguments): - return self.infer().execute(arguments) - - def execute_evaluated(self, *args, **kwargs): - return self.infer().execute_evaluated(*args, **kwargs) - - @property - def api_type(self): - return self.parent_context.api_type - - -class AbstractTreeName(AbstractNameDefinition): - def __init__(self, parent_context, tree_name): - self.parent_context = parent_context - self.tree_name = tree_name - - def goto(self): - return self.parent_context.evaluator.goto(self.parent_context, self.tree_name) - - @property - def string_name(self): - return self.tree_name.value - - @property - def start_pos(self): - return self.tree_name.start_pos - - -class ContextNameMixin(object): - def infer(self): - return ContextSet(self._context) - - def get_root_context(self): - if self.parent_context is None: - return self._context - return super(ContextNameMixin, self).get_root_context() - - @property - def api_type(self): - return self._context.api_type - - -class ContextName(ContextNameMixin, AbstractTreeName): - def __init__(self, context, tree_name): - super(ContextName, self).__init__(context.parent_context, tree_name) - self._context = context - - -class TreeNameDefinition(AbstractTreeName): - _API_TYPES = dict( - import_name='module', - import_from='module', - funcdef='function', - param='param', - classdef='class', - ) - - def infer(self): - # Refactor this, should probably be here. - from jedi.evaluate.syntax_tree import tree_name_to_contexts - return tree_name_to_contexts(self.parent_context.evaluator, self.parent_context, self.tree_name) - - @property - def api_type(self): - definition = self.tree_name.get_definition(import_name_always=True) - if definition is None: - return 'statement' - return self._API_TYPES.get(definition.type, 'statement') - - -class ParamName(AbstractTreeName): - api_type = 'param' - - def __init__(self, parent_context, tree_name): - self.parent_context = parent_context - self.tree_name = tree_name - - def infer(self): - return self.get_param().infer() - - def get_param(self): - params = self.parent_context.get_params() - param_node = search_ancestor(self.tree_name, 'param') - return params[param_node.position_index] - - -class AnonymousInstanceParamName(ParamName): - def infer(self): - param_node = search_ancestor(self.tree_name, 'param') - # TODO I think this should not belong here. It's not even really true, - # because classmethod and other descriptors can change it. - if param_node.position_index == 0: - # This is a speed optimization, to return the self param (because - # it's known). This only affects anonymous instances. - return ContextSet(self.parent_context.instance) - else: - return self.get_param().infer() - - -class AbstractFilter(object): - _until_position = None - - def _filter(self, names): - if self._until_position is not None: - return [n for n in names if n.start_pos < self._until_position] - return names - - @abstractmethod - def get(self, name): - raise NotImplementedError - - @abstractmethod - def values(self): - raise NotImplementedError - - -class AbstractUsedNamesFilter(AbstractFilter): - name_class = TreeNameDefinition - - def __init__(self, context, parser_scope): - self._parser_scope = parser_scope - self._used_names = self._parser_scope.get_root_node().get_used_names() - self.context = context - - def get(self, name): - try: - names = self._used_names[str(name)] - except KeyError: - return [] - - return self._convert_names(self._filter(names)) - - def _convert_names(self, names): - return [self.name_class(self.context, name) for name in names] - - def values(self): - return self._convert_names(name for name_list in self._used_names.values() - for name in self._filter(name_list)) - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self.context) - - -class ParserTreeFilter(AbstractUsedNamesFilter): - def __init__(self, evaluator, context, node_context=None, until_position=None, - origin_scope=None): - """ - node_context is an option to specify a second context for use cases - like the class mro where the parent class of a new name would be the - context, but for some type inference it's important to have a local - context of the other classes. - """ - if node_context is None: - node_context = context - super(ParserTreeFilter, self).__init__(context, node_context.tree_node) - self._node_context = node_context - self._origin_scope = origin_scope - self._until_position = until_position - - def _filter(self, names): - names = super(ParserTreeFilter, self)._filter(names) - names = [n for n in names if self._is_name_reachable(n)] - return list(self._check_flows(names)) - - def _is_name_reachable(self, name): - if not name.is_definition(): - return False - parent = name.parent - if parent.type == 'trailer': - return False - base_node = parent if parent.type in ('classdef', 'funcdef') else name - return get_parent_scope(base_node) == self._parser_scope - - def _check_flows(self, names): - for name in sorted(names, key=lambda name: name.start_pos, reverse=True): - check = flow_analysis.reachability_check( - self._node_context, self._parser_scope, name, self._origin_scope - ) - if check is not flow_analysis.UNREACHABLE: - yield name - - if check is flow_analysis.REACHABLE: - break - - -class FunctionExecutionFilter(ParserTreeFilter): - param_name = ParamName - - def __init__(self, evaluator, context, node_context=None, - until_position=None, origin_scope=None): - super(FunctionExecutionFilter, self).__init__( - evaluator, - context, - node_context, - until_position, - origin_scope - ) - - @to_list - def _convert_names(self, names): - for name in names: - param = search_ancestor(name, 'param') - if param: - yield self.param_name(self.context, name) - else: - yield TreeNameDefinition(self.context, name) - - -class AnonymousInstanceFunctionExecutionFilter(FunctionExecutionFilter): - param_name = AnonymousInstanceParamName - - -class GlobalNameFilter(AbstractUsedNamesFilter): - def __init__(self, context, parser_scope): - super(GlobalNameFilter, self).__init__(context, parser_scope) - - @to_list - def _filter(self, names): - for name in names: - if name.parent.type == 'global_stmt': - yield name - - -class DictFilter(AbstractFilter): - def __init__(self, dct): - self._dct = dct - - def get(self, name): - try: - value = self._convert(name, self._dct[str(name)]) - except KeyError: - return [] - - return list(self._filter([value])) - - def values(self): - return self._filter(self._convert(*item) for item in self._dct.items()) - - def _convert(self, name, value): - return value - - -class _BuiltinMappedMethod(Context): - """``Generator.__next__`` ``dict.values`` methods and so on.""" - api_type = 'function' - - def __init__(self, builtin_context, method, builtin_func): - super(_BuiltinMappedMethod, self).__init__( - builtin_context.evaluator, - parent_context=builtin_context - ) - self._method = method - self._builtin_func = builtin_func - - def py__call__(self, params): - return self._method(self.parent_context) - - def __getattr__(self, name): - return getattr(self._builtin_func, name) - - -class SpecialMethodFilter(DictFilter): - """ - A filter for methods that are defined in this module on the corresponding - classes like Generator (for __next__, etc). - """ - class SpecialMethodName(AbstractNameDefinition): - api_type = 'function' - - def __init__(self, parent_context, string_name, callable_, builtin_context): - self.parent_context = parent_context - self.string_name = string_name - self._callable = callable_ - self._builtin_context = builtin_context - - def infer(self): - filter = next(self._builtin_context.get_filters()) - # We can take the first index, because on builtin methods there's - # always only going to be one name. The same is true for the - # inferred values. - builtin_func = next(iter(filter.get(self.string_name)[0].infer())) - return ContextSet(_BuiltinMappedMethod(self.parent_context, self._callable, builtin_func)) - - def __init__(self, context, dct, builtin_context): - super(SpecialMethodFilter, self).__init__(dct) - self.context = context - self._builtin_context = builtin_context - """ - This context is what will be used to introspect the name, where as the - other context will be used to execute the function. - - We distinguish, because we have to. - """ - - def _convert(self, name, value): - return self.SpecialMethodName(self.context, name, value, self._builtin_context) - - -def has_builtin_methods(cls): - base_dct = {} - # Need to care properly about inheritance. Builtin Methods should not get - # lost, just because they are not mentioned in a class. - for base_cls in reversed(cls.__bases__): - try: - base_dct.update(base_cls.builtin_methods) - except AttributeError: - pass - - cls.builtin_methods = base_dct - for func in cls.__dict__.values(): - try: - cls.builtin_methods.update(func.registered_builtin_methods) - except AttributeError: - pass - return cls - - -def register_builtin_method(method_name, python_version_match=None): - def wrapper(func): - if python_version_match and python_version_match != 2 + int(is_py3): - # Some functions do only apply to certain versions. - return func - dct = func.__dict__.setdefault('registered_builtin_methods', {}) - dct[method_name] = func - return func - return wrapper - - -def get_global_filters(evaluator, context, until_position, origin_scope): - """ - Returns all filters in order of priority for name resolution. - - For global name lookups. The filters will handle name resolution - themselves, but here we gather possible filters downwards. - - >>> from jedi._compatibility import u, no_unicode_pprint - >>> from jedi import Script - >>> script = Script(u(''' - ... x = ['a', 'b', 'c'] - ... def func(): - ... y = None - ... ''')) - >>> module_node = script._get_module_node() - >>> scope = next(module_node.iter_funcdefs()) - >>> scope - - >>> context = script._get_module().create_context(scope) - >>> filters = list(get_global_filters(context.evaluator, context, (4, 0), None)) - - First we get the names names from the function scope. - - >>> no_unicode_pprint(filters[0]) - > - >>> sorted(str(n) for n in filters[0].values()) - ['', ''] - >>> filters[0]._until_position - (4, 0) - - Then it yields the names from one level "lower". In this example, this is - the module scope. As a side note, you can see, that the position in the - filter is now None, because typically the whole module is loaded before the - function is called. - - >>> filters[1].values() # global names -> there are none in our example. - [] - >>> list(filters[2].values()) # package modules -> Also empty. - [] - >>> sorted(name.string_name for name in filters[3].values()) # Module attributes - ['__doc__', '__file__', '__name__', '__package__'] - >>> print(filters[1]._until_position) - None - - Finally, it yields the builtin filter, if `include_builtin` is - true (default). - - >>> filters[4].values() #doctest: +ELLIPSIS - [, ...] - """ - from jedi.evaluate.context.function import FunctionExecutionContext - while context is not None: - # Names in methods cannot be resolved within the class. - for filter in context.get_filters( - search_global=True, - until_position=until_position, - origin_scope=origin_scope): - yield filter - if isinstance(context, FunctionExecutionContext): - # The position should be reset if the current scope is a function. - until_position = None - - context = context.parent_context - - # Add builtins to the global scope. - for filter in evaluator.BUILTINS.get_filters(search_global=True): - yield filter diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/finder.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/finder.py deleted file mode 100644 index 96032ae..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/finder.py +++ /dev/null @@ -1,258 +0,0 @@ -""" -Searching for names with given scope and name. This is very central in Jedi and -Python. The name resolution is quite complicated with descripter, -``__getattribute__``, ``__getattr__``, ``global``, etc. - -If you want to understand name resolution, please read the first few chapters -in http://blog.ionelmc.ro/2015/02/09/understanding-python-metaclasses/. - -Flow checks -+++++++++++ - -Flow checks are not really mature. There's only a check for ``isinstance``. It -would check whether a flow has the form of ``if isinstance(a, type_or_tuple)``. -Unfortunately every other thing is being ignored (e.g. a == '' would be easy to -check for -> a is a string). There's big potential in these checks. -""" - -from parso.python import tree -from parso.tree import search_ancestor -from jedi import debug -from jedi import settings -from jedi.evaluate.context import AbstractInstanceContext -from jedi.evaluate import compiled -from jedi.evaluate import analysis -from jedi.evaluate import flow_analysis -from jedi.evaluate.arguments import TreeArguments -from jedi.evaluate import helpers -from jedi.evaluate.context import iterable -from jedi.evaluate.filters import get_global_filters, TreeNameDefinition -from jedi.evaluate.base_context import ContextSet -from jedi.parser_utils import is_scope, get_parent_scope - - -class NameFinder(object): - def __init__(self, evaluator, context, name_context, name_or_str, - position=None, analysis_errors=True): - self._evaluator = evaluator - # Make sure that it's not just a syntax tree node. - self._context = context - self._name_context = name_context - self._name = name_or_str - if isinstance(name_or_str, tree.Name): - self._string_name = name_or_str.value - else: - self._string_name = name_or_str - self._position = position - self._found_predefined_types = None - self._analysis_errors = analysis_errors - - @debug.increase_indent - def find(self, filters, attribute_lookup): - """ - :params bool attribute_lookup: Tell to logic if we're accessing the - attribute or the contents of e.g. a function. - """ - names = self.filter_name(filters) - if self._found_predefined_types is not None and names: - check = flow_analysis.reachability_check( - self._context, self._context.tree_node, self._name) - if check is flow_analysis.UNREACHABLE: - return ContextSet() - return self._found_predefined_types - - types = self._names_to_types(names, attribute_lookup) - - if not names and self._analysis_errors and not types \ - and not (isinstance(self._name, tree.Name) and - isinstance(self._name.parent.parent, tree.Param)): - if isinstance(self._name, tree.Name): - if attribute_lookup: - analysis.add_attribute_error( - self._name_context, self._context, self._name) - else: - message = ("NameError: name '%s' is not defined." - % self._string_name) - analysis.add(self._name_context, 'name-error', self._name, message) - - return types - - def _get_origin_scope(self): - if isinstance(self._name, tree.Name): - scope = self._name - while scope.parent is not None: - # TODO why if classes? - if not isinstance(scope, tree.Scope): - break - scope = scope.parent - return scope - else: - return None - - def get_filters(self, search_global=False): - origin_scope = self._get_origin_scope() - if search_global: - return get_global_filters(self._evaluator, self._context, self._position, origin_scope) - else: - return self._context.get_filters(search_global, self._position, origin_scope=origin_scope) - - def filter_name(self, filters): - """ - Searches names that are defined in a scope (the different - ``filters``), until a name fits. - """ - names = [] - if self._context.predefined_names: - # TODO is this ok? node might not always be a tree.Name - node = self._name - while node is not None and not is_scope(node): - node = node.parent - if node.type in ("if_stmt", "for_stmt", "comp_for"): - try: - name_dict = self._context.predefined_names[node] - types = name_dict[self._string_name] - except KeyError: - continue - else: - self._found_predefined_types = types - break - - for filter in filters: - names = filter.get(self._string_name) - if names: - if len(names) == 1: - n, = names - if isinstance(n, TreeNameDefinition): - # Something somewhere went terribly wrong. This - # typically happens when using goto on an import in an - # __init__ file. I think we need a better solution, but - # it's kind of hard, because for Jedi it's not clear - # that that name has not been defined, yet. - if n.tree_name == self._name: - if self._name.get_definition().type == 'import_from': - continue - break - - debug.dbg('finder.filter_name "%s" in (%s): %s@%s', self._string_name, - self._context, names, self._position) - return list(names) - - def _check_getattr(self, inst): - """Checks for both __getattr__ and __getattribute__ methods""" - # str is important, because it shouldn't be `Name`! - name = compiled.create(self._evaluator, self._string_name) - - # This is a little bit special. `__getattribute__` is in Python - # executed before `__getattr__`. But: I know no use case, where - # this could be practical and where Jedi would return wrong types. - # If you ever find something, let me know! - # We are inversing this, because a hand-crafted `__getattribute__` - # could still call another hand-crafted `__getattr__`, but not the - # other way around. - names = (inst.get_function_slot_names('__getattr__') or - inst.get_function_slot_names('__getattribute__')) - return inst.execute_function_slots(names, name) - - def _names_to_types(self, names, attribute_lookup): - contexts = ContextSet.from_sets(name.infer() for name in names) - - debug.dbg('finder._names_to_types: %s -> %s', names, contexts) - if not names and isinstance(self._context, AbstractInstanceContext): - # handling __getattr__ / __getattribute__ - return self._check_getattr(self._context) - - # Add isinstance and other if/assert knowledge. - if not contexts and isinstance(self._name, tree.Name) and \ - not isinstance(self._name_context, AbstractInstanceContext): - flow_scope = self._name - base_node = self._name_context.tree_node - if base_node.type == 'comp_for': - return contexts - while True: - flow_scope = get_parent_scope(flow_scope, include_flows=True) - n = _check_flow_information(self._name_context, flow_scope, - self._name, self._position) - if n is not None: - return n - if flow_scope == base_node: - break - return contexts - - -def _check_flow_information(context, flow, search_name, pos): - """ Try to find out the type of a variable just with the information that - is given by the flows: e.g. It is also responsible for assert checks.:: - - if isinstance(k, str): - k. # <- completion here - - ensures that `k` is a string. - """ - if not settings.dynamic_flow_information: - return None - - result = None - if is_scope(flow): - # Check for asserts. - module_node = flow.get_root_node() - try: - names = module_node.get_used_names()[search_name.value] - except KeyError: - return None - names = reversed([ - n for n in names - if flow.start_pos <= n.start_pos < (pos or flow.end_pos) - ]) - - for name in names: - ass = search_ancestor(name, 'assert_stmt') - if ass is not None: - result = _check_isinstance_type(context, ass.assertion, search_name) - if result is not None: - return result - - if flow.type in ('if_stmt', 'while_stmt'): - potential_ifs = [c for c in flow.children[1::4] if c != ':'] - for if_test in reversed(potential_ifs): - if search_name.start_pos > if_test.end_pos: - return _check_isinstance_type(context, if_test, search_name) - return result - - -def _check_isinstance_type(context, element, search_name): - try: - assert element.type in ('power', 'atom_expr') - # this might be removed if we analyze and, etc - assert len(element.children) == 2 - first, trailer = element.children - assert first.type == 'name' and first.value == 'isinstance' - assert trailer.type == 'trailer' and trailer.children[0] == '(' - assert len(trailer.children) == 3 - - # arglist stuff - arglist = trailer.children[1] - args = TreeArguments(context.evaluator, context, arglist, trailer) - param_list = list(args.unpack()) - # Disallow keyword arguments - assert len(param_list) == 2 - (key1, lazy_context_object), (key2, lazy_context_cls) = param_list - assert key1 is None and key2 is None - call = helpers.call_of_leaf(search_name) - is_instance_call = helpers.call_of_leaf(lazy_context_object.data) - # Do a simple get_code comparison. They should just have the same code, - # and everything will be all right. - normalize = context.evaluator.grammar._normalize - assert normalize(is_instance_call) == normalize(call) - except AssertionError: - return None - - context_set = ContextSet() - for cls_or_tup in lazy_context_cls.infer(): - if isinstance(cls_or_tup, iterable.AbstractIterable) and \ - cls_or_tup.array_type == 'tuple': - for lazy_context in cls_or_tup.py__iter__(): - for context in lazy_context.infer(): - context_set |= context.execute_evaluated() - else: - context_set |= cls_or_tup.execute_evaluated() - return context_set diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/flow_analysis.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/flow_analysis.py deleted file mode 100644 index 670b7a7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/flow_analysis.py +++ /dev/null @@ -1,112 +0,0 @@ -from jedi.parser_utils import get_flow_branch_keyword, is_scope, get_parent_scope - - -class Status(object): - lookup_table = {} - - def __init__(self, value, name): - self._value = value - self._name = name - Status.lookup_table[value] = self - - def invert(self): - if self is REACHABLE: - return UNREACHABLE - elif self is UNREACHABLE: - return REACHABLE - else: - return UNSURE - - def __and__(self, other): - if UNSURE in (self, other): - return UNSURE - else: - return REACHABLE if self._value and other._value else UNREACHABLE - - def __repr__(self): - return '<%s: %s>' % (type(self).__name__, self._name) - - -REACHABLE = Status(True, 'reachable') -UNREACHABLE = Status(False, 'unreachable') -UNSURE = Status(None, 'unsure') - - -def _get_flow_scopes(node): - while True: - node = get_parent_scope(node, include_flows=True) - if node is None or is_scope(node): - return - yield node - - -def reachability_check(context, context_scope, node, origin_scope=None): - first_flow_scope = get_parent_scope(node, include_flows=True) - if origin_scope is not None: - origin_flow_scopes = list(_get_flow_scopes(origin_scope)) - node_flow_scopes = list(_get_flow_scopes(node)) - - branch_matches = True - for flow_scope in origin_flow_scopes: - if flow_scope in node_flow_scopes: - node_keyword = get_flow_branch_keyword(flow_scope, node) - origin_keyword = get_flow_branch_keyword(flow_scope, origin_scope) - branch_matches = node_keyword == origin_keyword - if flow_scope.type == 'if_stmt': - if not branch_matches: - return UNREACHABLE - elif flow_scope.type == 'try_stmt': - if not branch_matches and origin_keyword == 'else' \ - and node_keyword == 'except': - return UNREACHABLE - break - - # Direct parents get resolved, we filter scopes that are separate - # branches. This makes sense for autocompletion and static analysis. - # For actual Python it doesn't matter, because we're talking about - # potentially unreachable code. - # e.g. `if 0:` would cause all name lookup within the flow make - # unaccessible. This is not a "problem" in Python, because the code is - # never called. In Jedi though, we still want to infer types. - while origin_scope is not None: - if first_flow_scope == origin_scope and branch_matches: - return REACHABLE - origin_scope = origin_scope.parent - - return _break_check(context, context_scope, first_flow_scope, node) - - -def _break_check(context, context_scope, flow_scope, node): - reachable = REACHABLE - if flow_scope.type == 'if_stmt': - if flow_scope.is_node_after_else(node): - for check_node in flow_scope.get_test_nodes(): - reachable = _check_if(context, check_node) - if reachable in (REACHABLE, UNSURE): - break - reachable = reachable.invert() - else: - flow_node = flow_scope.get_corresponding_test_node(node) - if flow_node is not None: - reachable = _check_if(context, flow_node) - elif flow_scope.type in ('try_stmt', 'while_stmt'): - return UNSURE - - # Only reachable branches need to be examined further. - if reachable in (UNREACHABLE, UNSURE): - return reachable - - if context_scope != flow_scope and context_scope != flow_scope.parent: - flow_scope = get_parent_scope(flow_scope, include_flows=True) - return reachable & _break_check(context, context_scope, flow_scope, node) - else: - return reachable - - -def _check_if(context, node): - types = context.eval_node(node) - values = set(x.py__bool__() for x in types) - if len(values) == 1: - return Status.lookup_table[values.pop()] - else: - return UNSURE diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/helpers.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/helpers.py deleted file mode 100644 index 3b21e01..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/helpers.py +++ /dev/null @@ -1,201 +0,0 @@ -import copy -import sys -import re -import os -from itertools import chain -from contextlib import contextmanager - -from parso.python import tree - -from jedi._compatibility import unicode -from jedi.parser_utils import get_parent_scope -from jedi.evaluate.compiled import CompiledObject - - -def is_stdlib_path(path): - # Python standard library paths look like this: - # /usr/lib/python3.5/... - # TODO The implementation below is probably incorrect and not complete. - if 'dist-packages' in path or 'site-packages' in path: - return False - - base_path = os.path.join(sys.prefix, 'lib', 'python') - return bool(re.match(re.escape(base_path) + '\d.\d', path)) - - -def deep_ast_copy(obj): - """ - Much, much faster than copy.deepcopy, but just for parser tree nodes. - """ - # If it's already in the cache, just return it. - new_obj = copy.copy(obj) - - # Copy children - new_children = [] - for child in obj.children: - if isinstance(child, tree.Leaf): - new_child = copy.copy(child) - new_child.parent = new_obj - else: - new_child = deep_ast_copy(child) - new_child.parent = new_obj - new_children.append(new_child) - new_obj.children = new_children - - return new_obj - - -def evaluate_call_of_leaf(context, leaf, cut_own_trailer=False): - """ - Creates a "call" node that consist of all ``trailer`` and ``power`` - objects. E.g. if you call it with ``append``:: - - list([]).append(3) or None - - You would get a node with the content ``list([]).append`` back. - - This generates a copy of the original ast node. - - If you're using the leaf, e.g. the bracket `)` it will return ``list([])``. - - We use this function for two purposes. Given an expression ``bar.foo``, - we may want to - - infer the type of ``foo`` to offer completions after foo - - infer the type of ``bar`` to be able to jump to the definition of foo - The option ``cut_own_trailer`` must be set to true for the second purpose. - """ - trailer = leaf.parent - # The leaf may not be the last or first child, because there exist three - # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples - # we should not match anything more than x. - if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]): - if trailer.type == 'atom': - return context.eval_node(trailer) - return context.eval_node(leaf) - - power = trailer.parent - index = power.children.index(trailer) - if cut_own_trailer: - cut = index - else: - cut = index + 1 - - if power.type == 'error_node': - start = index - while True: - start -= 1 - base = power.children[start] - if base.type != 'trailer': - break - trailers = power.children[start + 1: index + 1] - else: - base = power.children[0] - trailers = power.children[1:cut] - - if base == 'await': - base = trailers[0] - trailers = trailers[1:] - - values = context.eval_node(base) - from jedi.evaluate.syntax_tree import eval_trailer - for trailer in trailers: - values = eval_trailer(context, values, trailer) - return values - - -def call_of_leaf(leaf): - """ - Creates a "call" node that consist of all ``trailer`` and ``power`` - objects. E.g. if you call it with ``append``:: - - list([]).append(3) or None - - You would get a node with the content ``list([]).append`` back. - - This generates a copy of the original ast node. - - If you're using the leaf, e.g. the bracket `)` it will return ``list([])``. - """ - # TODO this is the old version of this call. Try to remove it. - trailer = leaf.parent - # The leaf may not be the last or first child, because there exist three - # different trailers: `( x )`, `[ x ]` and `.x`. In the first two examples - # we should not match anything more than x. - if trailer.type != 'trailer' or leaf not in (trailer.children[0], trailer.children[-1]): - if trailer.type == 'atom': - return trailer - return leaf - - power = trailer.parent - index = power.children.index(trailer) - - new_power = copy.copy(power) - new_power.children = list(new_power.children) - new_power.children[index + 1:] = [] - - if power.type == 'error_node': - start = index - while True: - start -= 1 - if power.children[start].type != 'trailer': - break - transformed = tree.Node('power', power.children[start:]) - transformed.parent = power.parent - return transformed - - return power - - -def get_names_of_node(node): - try: - children = node.children - except AttributeError: - if node.type == 'name': - return [node] - else: - return [] - else: - return list(chain.from_iterable(get_names_of_node(c) for c in children)) - - -def get_module_names(module, all_scopes): - """ - Returns a dictionary with name parts as keys and their call paths as - values. - """ - names = chain.from_iterable(module.get_used_names().values()) - if not all_scopes: - # We have to filter all the names that don't have the module as a - # parent_scope. There's None as a parent, because nodes in the module - # node have the parent module and not suite as all the others. - # Therefore it's important to catch that case. - names = [n for n in names if get_parent_scope(n).parent in (module, None)] - return names - - -@contextmanager -def predefine_names(context, flow_scope, dct): - predefined = context.predefined_names - if flow_scope in predefined: - raise NotImplementedError('Why does this happen?') - predefined[flow_scope] = dct - try: - yield - finally: - del predefined[flow_scope] - - -def is_compiled(context): - return isinstance(context, CompiledObject) - - -def is_string(context): - return is_compiled(context) and isinstance(context.obj, (str, unicode)) - - -def is_literal(context): - return is_number(context) or is_string(context) - - -def is_number(context): - return is_compiled(context) and isinstance(context.obj, (int, float)) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/imports.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/imports.py deleted file mode 100644 index ecf656b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/imports.py +++ /dev/null @@ -1,570 +0,0 @@ -""" -:mod:`jedi.evaluate.imports` is here to resolve import statements and return -the modules/classes/functions/whatever, which they stand for. However there's -not any actual importing done. This module is about finding modules in the -filesystem. This can be quite tricky sometimes, because Python imports are not -always that simple. - -This module uses imp for python up to 3.2 and importlib for python 3.3 on; the -correct implementation is delegated to _compatibility. - -This module also supports import autocompletion, which means to complete -statements like ``from datetim`` (curser at the end would return ``datetime``). -""" -import imp -import os -import pkgutil -import sys - -from parso.python import tree -from parso.tree import search_ancestor -from parso.cache import parser_cache -from parso import python_bytes_to_unicode - -from jedi._compatibility import find_module, unicode, ImplicitNSInfo -from jedi import debug -from jedi import settings -from jedi.evaluate import sys_path -from jedi.evaluate import helpers -from jedi.evaluate import compiled -from jedi.evaluate import analysis -from jedi.evaluate.utils import unite -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.filters import AbstractNameDefinition -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS - - -# This memoization is needed, because otherwise we will infinitely loop on -# certain imports. -@evaluator_method_cache(default=NO_CONTEXTS) -def infer_import(context, tree_name, is_goto=False): - module_context = context.get_root_context() - import_node = search_ancestor(tree_name, 'import_name', 'import_from') - import_path = import_node.get_path_for_name(tree_name) - from_import_name = None - evaluator = context.evaluator - try: - from_names = import_node.get_from_names() - except AttributeError: - # Is an import_name - pass - else: - if len(from_names) + 1 == len(import_path): - # We have to fetch the from_names part first and then check - # if from_names exists in the modules. - from_import_name = import_path[-1] - import_path = from_names - - importer = Importer(evaluator, tuple(import_path), - module_context, import_node.level) - - types = importer.follow() - - #if import_node.is_nested() and not self.nested_resolve: - # scopes = [NestedImportModule(module, import_node)] - - if not types: - return NO_CONTEXTS - - if from_import_name is not None: - types = unite( - t.py__getattribute__( - from_import_name, - name_context=context, - is_goto=is_goto, - analysis_errors=False - ) - for t in types - ) - if not is_goto: - types = ContextSet.from_set(types) - - if not types: - path = import_path + [from_import_name] - importer = Importer(evaluator, tuple(path), - module_context, import_node.level) - types = importer.follow() - # goto only accepts `Name` - if is_goto: - types = set(s.name for s in types) - else: - # goto only accepts `Name` - if is_goto: - types = set(s.name for s in types) - - debug.dbg('after import: %s', types) - return types - - -class NestedImportModule(tree.Module): - """ - TODO while there's no use case for nested import module right now, we might - be able to use them for static analysis checks later on. - """ - def __init__(self, module, nested_import): - self._module = module - self._nested_import = nested_import - - def _get_nested_import_name(self): - """ - Generates an Import statement, that can be used to fake nested imports. - """ - i = self._nested_import - # This is not an existing Import statement. Therefore, set position to - # 0 (0 is not a valid line number). - zero = (0, 0) - names = [unicode(name) for name in i.namespace_names[1:]] - name = helpers.FakeName(names, self._nested_import) - new = tree.Import(i._sub_module, zero, zero, name) - new.parent = self._module - debug.dbg('Generated a nested import: %s', new) - return helpers.FakeName(str(i.namespace_names[1]), new) - - def __getattr__(self, name): - return getattr(self._module, name) - - def __repr__(self): - return "<%s: %s of %s>" % (self.__class__.__name__, self._module, - self._nested_import) - - -def _add_error(context, name, message=None): - # Should be a name, not a string! - if hasattr(name, 'parent'): - analysis.add(context, 'import-error', name, message) - - -def get_init_path(directory_path): - """ - The __init__ file can be searched in a directory. If found return it, else - None. - """ - for suffix, _, _ in imp.get_suffixes(): - path = os.path.join(directory_path, '__init__' + suffix) - if os.path.exists(path): - return path - return None - - -class ImportName(AbstractNameDefinition): - start_pos = (1, 0) - _level = 0 - - def __init__(self, parent_context, string_name): - self.parent_context = parent_context - self.string_name = string_name - - def infer(self): - return Importer( - self.parent_context.evaluator, - [self.string_name], - self.parent_context, - level=self._level, - ).follow() - - def goto(self): - return [m.name for m in self.infer()] - - def get_root_context(self): - # Not sure if this is correct. - return self.parent_context.get_root_context() - - @property - def api_type(self): - return 'module' - - -class SubModuleName(ImportName): - _level = 1 - - -class Importer(object): - def __init__(self, evaluator, import_path, module_context, level=0): - """ - An implementation similar to ``__import__``. Use `follow` - to actually follow the imports. - - *level* specifies whether to use absolute or relative imports. 0 (the - default) means only perform absolute imports. Positive values for level - indicate the number of parent directories to search relative to the - directory of the module calling ``__import__()`` (see PEP 328 for the - details). - - :param import_path: List of namespaces (strings or Names). - """ - debug.speed('import %s' % (import_path,)) - self._evaluator = evaluator - self.level = level - self.module_context = module_context - try: - self.file_path = module_context.py__file__() - except AttributeError: - # Can be None for certain compiled modules like 'builtins'. - self.file_path = None - - if level: - base = module_context.py__package__().split('.') - if base == ['']: - base = [] - if level > len(base): - path = module_context.py__file__() - if path is not None: - import_path = list(import_path) - p = path - for i in range(level): - p = os.path.dirname(p) - dir_name = os.path.basename(p) - # This is not the proper way to do relative imports. However, since - # Jedi cannot be sure about the entry point, we just calculate an - # absolute path here. - if dir_name: - # TODO those sys.modules modifications are getting - # really stupid. this is the 3rd time that we're using - # this. We should probably refactor. - if path.endswith(os.path.sep + 'os.py'): - import_path.insert(0, 'os') - else: - import_path.insert(0, dir_name) - else: - _add_error(module_context, import_path[-1]) - import_path = [] - # TODO add import error. - debug.warning('Attempted relative import beyond top-level package.') - # If no path is defined in the module we have no ideas where we - # are in the file system. Therefore we cannot know what to do. - # In this case we just let the path there and ignore that it's - # a relative path. Not sure if that's a good idea. - else: - # Here we basically rewrite the level to 0. - base = tuple(base) - if level > 1: - base = base[:-level + 1] - - import_path = base + tuple(import_path) - self.import_path = import_path - - @property - def str_import_path(self): - """Returns the import path as pure strings instead of `Name`.""" - return tuple( - name.value if isinstance(name, tree.Name) else name - for name in self.import_path) - - def sys_path_with_modifications(self): - in_path = [] - sys_path_mod = self._evaluator.project.sys_path \ - + sys_path.check_sys_path_modifications(self.module_context) - if self.file_path is not None: - # If you edit e.g. gunicorn, there will be imports like this: - # `from gunicorn import something`. But gunicorn is not in the - # sys.path. Therefore look if gunicorn is a parent directory, #56. - if self.import_path: # TODO is this check really needed? - for path in sys_path.traverse_parents(self.file_path): - if os.path.basename(path) == self.str_import_path[0]: - in_path.append(os.path.dirname(path)) - - # Since we know nothing about the call location of the sys.path, - # it's a possibility that the current directory is the origin of - # the Python execution. - sys_path_mod.insert(0, os.path.dirname(self.file_path)) - - return in_path + sys_path_mod - - def follow(self): - if not self.import_path: - return NO_CONTEXTS - return self._do_import(self.import_path, self.sys_path_with_modifications()) - - def _do_import(self, import_path, sys_path): - """ - This method is very similar to importlib's `_gcd_import`. - """ - import_parts = [ - i.value if isinstance(i, tree.Name) else i - for i in import_path - ] - - # Handle "magic" Flask extension imports: - # ``flask.ext.foo`` is really ``flask_foo`` or ``flaskext.foo``. - if len(import_path) > 2 and import_parts[:2] == ['flask', 'ext']: - # New style. - ipath = ('flask_' + str(import_parts[2]),) + import_path[3:] - modules = self._do_import(ipath, sys_path) - if modules: - return modules - else: - # Old style - return self._do_import(('flaskext',) + import_path[2:], sys_path) - - module_name = '.'.join(import_parts) - try: - return ContextSet(self._evaluator.modules[module_name]) - except KeyError: - pass - - if len(import_path) > 1: - # This is a recursive way of importing that works great with - # the module cache. - bases = self._do_import(import_path[:-1], sys_path) - if not bases: - return NO_CONTEXTS - # We can take the first element, because only the os special - # case yields multiple modules, which is not important for - # further imports. - parent_module = list(bases)[0] - - # This is a huge exception, we follow a nested import - # ``os.path``, because it's a very important one in Python - # that is being achieved by messing with ``sys.modules`` in - # ``os``. - if import_parts == ['os', 'path']: - return parent_module.py__getattribute__('path') - - try: - method = parent_module.py__path__ - except AttributeError: - # The module is not a package. - _add_error(self.module_context, import_path[-1]) - return NO_CONTEXTS - else: - paths = method() - debug.dbg('search_module %s in paths %s', module_name, paths) - for path in paths: - # At the moment we are only using one path. So this is - # not important to be correct. - try: - if not isinstance(path, list): - path = [path] - module_file, module_path, is_pkg = \ - find_module(import_parts[-1], path, fullname=module_name) - break - except ImportError: - module_path = None - if module_path is None: - _add_error(self.module_context, import_path[-1]) - return NO_CONTEXTS - else: - parent_module = None - try: - debug.dbg('search_module %s in %s', import_parts[-1], self.file_path) - # Override the sys.path. It works only good that way. - # Injecting the path directly into `find_module` did not work. - sys.path, temp = sys_path, sys.path - try: - module_file, module_path, is_pkg = \ - find_module(import_parts[-1], fullname=module_name) - finally: - sys.path = temp - except ImportError: - # The module is not a package. - _add_error(self.module_context, import_path[-1]) - return NO_CONTEXTS - - code = None - if is_pkg: - # In this case, we don't have a file yet. Search for the - # __init__ file. - if module_path.endswith(('.zip', '.egg')): - code = module_file.loader.get_source(module_name) - else: - module_path = get_init_path(module_path) - elif module_file: - code = module_file.read() - module_file.close() - - if isinstance(module_path, ImplicitNSInfo): - from jedi.evaluate.context.namespace import ImplicitNamespaceContext - fullname, paths = module_path.name, module_path.paths - module = ImplicitNamespaceContext(self._evaluator, fullname=fullname) - module.paths = paths - elif module_file is None and not module_path.endswith(('.py', '.zip', '.egg')): - module = compiled.load_module(self._evaluator, module_path) - else: - module = _load_module(self._evaluator, module_path, code, sys_path, parent_module) - - if module is None: - # The file might raise an ImportError e.g. and therefore not be - # importable. - return NO_CONTEXTS - - self._evaluator.modules[module_name] = module - return ContextSet(module) - - def _generate_name(self, name, in_module=None): - # Create a pseudo import to be able to follow them. - if in_module is None: - return ImportName(self.module_context, name) - return SubModuleName(in_module, name) - - def _get_module_names(self, search_path=None, in_module=None): - """ - Get the names of all modules in the search_path. This means file names - and not names defined in the files. - """ - - names = [] - # add builtin module names - if search_path is None and in_module is None: - names += [self._generate_name(name) for name in sys.builtin_module_names] - - if search_path is None: - search_path = self.sys_path_with_modifications() - for module_loader, name, is_pkg in pkgutil.iter_modules(search_path): - names.append(self._generate_name(name, in_module=in_module)) - return names - - def completion_names(self, evaluator, only_modules=False): - """ - :param only_modules: Indicates wheter it's possible to import a - definition that is not defined in a module. - """ - from jedi.evaluate.context import ModuleContext - from jedi.evaluate.context.namespace import ImplicitNamespaceContext - names = [] - if self.import_path: - # flask - if self.str_import_path == ('flask', 'ext'): - # List Flask extensions like ``flask_foo`` - for mod in self._get_module_names(): - modname = mod.string_name - if modname.startswith('flask_'): - extname = modname[len('flask_'):] - names.append(self._generate_name(extname)) - # Now the old style: ``flaskext.foo`` - for dir in self.sys_path_with_modifications(): - flaskext = os.path.join(dir, 'flaskext') - if os.path.isdir(flaskext): - names += self._get_module_names([flaskext]) - - for context in self.follow(): - # Non-modules are not completable. - if context.api_type != 'module': # not a module - continue - # namespace packages - if isinstance(context, ModuleContext) and context.py__file__().endswith('__init__.py'): - paths = context.py__path__() - names += self._get_module_names(paths, in_module=context) - - # implicit namespace packages - elif isinstance(context, ImplicitNamespaceContext): - paths = context.paths - names += self._get_module_names(paths) - - if only_modules: - # In the case of an import like `from x.` we don't need to - # add all the variables. - if ('os',) == self.str_import_path and not self.level: - # os.path is a hardcoded exception, because it's a - # ``sys.modules`` modification. - names.append(self._generate_name('path', context)) - - continue - - for filter in context.get_filters(search_global=False): - names += filter.values() - else: - # Empty import path=completion after import - if not self.level: - names += self._get_module_names() - - if self.file_path is not None: - path = os.path.abspath(self.file_path) - for i in range(self.level - 1): - path = os.path.dirname(path) - names += self._get_module_names([path]) - - return names - - -def _load_module(evaluator, path=None, code=None, sys_path=None, parent_module=None): - if sys_path is None: - sys_path = evaluator.project.sys_path - - dotted_path = path and compiled.dotted_from_fs_path(path, sys_path) - if path is not None and path.endswith(('.py', '.zip', '.egg')) \ - and dotted_path not in settings.auto_import_modules: - - module_node = evaluator.grammar.parse( - code=code, path=path, cache=True, diff_cache=True, - cache_path=settings.cache_directory) - - from jedi.evaluate.context import ModuleContext - return ModuleContext(evaluator, module_node, path=path) - else: - return compiled.load_module(evaluator, path) - - -def add_module(evaluator, module_name, module): - if '.' not in module_name: - # We cannot add paths with dots, because that would collide with - # the sepatator dots for nested packages. Therefore we return - # `__main__` in ModuleWrapper.py__name__(), which is similar to - # Python behavior. - evaluator.modules[module_name] = module - - -def get_modules_containing_name(evaluator, modules, name): - """ - Search a name in the directories of modules. - """ - from jedi.evaluate.context import ModuleContext - def check_directories(paths): - for p in paths: - if p is not None: - # We need abspath, because the seetings paths might not already - # have been converted to absolute paths. - d = os.path.dirname(os.path.abspath(p)) - for file_name in os.listdir(d): - path = os.path.join(d, file_name) - if file_name.endswith('.py'): - yield path - - def check_python_file(path): - try: - # TODO I don't think we should use the cache here?! - node_cache_item = parser_cache[evaluator.grammar._hashed][path] - except KeyError: - try: - return check_fs(path) - except IOError: - return None - else: - module_node = node_cache_item.node - return ModuleContext(evaluator, module_node, path=path) - - def check_fs(path): - with open(path, 'rb') as f: - code = python_bytes_to_unicode(f.read(), errors='replace') - if name in code: - module = _load_module(evaluator, path, code) - - module_name = sys_path.dotted_path_in_sys_path(evaluator.project.sys_path, path) - if module_name is not None: - add_module(evaluator, module_name, module) - return module - - # skip non python modules - used_mod_paths = set() - for m in modules: - try: - path = m.py__file__() - except AttributeError: - pass - else: - used_mod_paths.add(path) - yield m - - if not settings.dynamic_params_for_other_modules: - return - - additional = set(os.path.abspath(p) for p in settings.additional_dynamic_modules) - # Check the directories of used modules. - paths = (additional | set(check_directories(used_mod_paths))) \ - - used_mod_paths - - # Sort here to make issues less random. - for p in sorted(paths): - # make testing easier, sort it - same results on every interpreter - m = check_python_file(p) - if m is not None and not isinstance(m, compiled.CompiledObject): - yield m diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/jedi_typing.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/jedi_typing.py deleted file mode 100644 index f48a567..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/jedi_typing.py +++ /dev/null @@ -1,100 +0,0 @@ -""" -This module is not intended to be used in jedi, rather it will be fed to the -jedi-parser to replace classes in the typing module -""" - -try: - from collections import abc -except ImportError: - # python 2 - import collections as abc - - -def factory(typing_name, indextypes): - class Iterable(abc.Iterable): - def __iter__(self): - while True: - yield indextypes[0]() - - class Iterator(Iterable, abc.Iterator): - def next(self): - """ needed for python 2 """ - return self.__next__() - - def __next__(self): - return indextypes[0]() - - class Sequence(abc.Sequence): - def __getitem__(self, index): - return indextypes[0]() - - class MutableSequence(Sequence, abc.MutableSequence): - pass - - class List(MutableSequence, list): - pass - - class Tuple(Sequence, tuple): - def __getitem__(self, index): - if indextypes[1] == Ellipsis: - # https://www.python.org/dev/peps/pep-0484/#the-typing-module - # Tuple[int, ...] means a tuple of ints of indetermined length - return indextypes[0]() - else: - return indextypes[index]() - - class AbstractSet(Iterable, abc.Set): - pass - - class MutableSet(AbstractSet, abc.MutableSet): - pass - - class KeysView(Iterable, abc.KeysView): - pass - - class ValuesView(abc.ValuesView): - def __iter__(self): - while True: - yield indextypes[1]() - - class ItemsView(abc.ItemsView): - def __iter__(self): - while True: - yield (indextypes[0](), indextypes[1]()) - - class Mapping(Iterable, abc.Mapping): - def __getitem__(self, item): - return indextypes[1]() - - def keys(self): - return KeysView() - - def values(self): - return ValuesView() - - def items(self): - return ItemsView() - - class MutableMapping(Mapping, abc.MutableMapping): - pass - - class Dict(MutableMapping, dict): - pass - - dct = { - "Sequence": Sequence, - "MutableSequence": MutableSequence, - "List": List, - "Iterable": Iterable, - "Iterator": Iterator, - "AbstractSet": AbstractSet, - "MutableSet": MutableSet, - "Mapping": Mapping, - "MutableMapping": MutableMapping, - "Tuple": Tuple, - "KeysView": KeysView, - "ItemsView": ItemsView, - "ValuesView": ValuesView, - "Dict": Dict, - } - return dct[typing_name] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/lazy_context.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/lazy_context.py deleted file mode 100644 index 9380212..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/lazy_context.py +++ /dev/null @@ -1,61 +0,0 @@ -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS - -class AbstractLazyContext(object): - def __init__(self, data): - self.data = data - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self.data) - - def infer(self): - raise NotImplementedError - - -class LazyKnownContext(AbstractLazyContext): - """data is a context.""" - def infer(self): - return ContextSet(self.data) - - -class LazyKnownContexts(AbstractLazyContext): - """data is a ContextSet.""" - def infer(self): - return self.data - - -class LazyUnknownContext(AbstractLazyContext): - def __init__(self): - super(LazyUnknownContext, self).__init__(None) - - def infer(self): - return NO_CONTEXTS - - -class LazyTreeContext(AbstractLazyContext): - def __init__(self, context, node): - super(LazyTreeContext, self).__init__(node) - self._context = context - # We need to save the predefined names. It's an unfortunate side effect - # that needs to be tracked otherwise results will be wrong. - self._predefined_names = dict(context.predefined_names) - - def infer(self): - old, self._context.predefined_names = \ - self._context.predefined_names, self._predefined_names - try: - return self._context.eval_node(self.data) - finally: - self._context.predefined_names = old - - -def get_merged_lazy_context(lazy_contexts): - if len(lazy_contexts) > 1: - return MergedLazyContexts(lazy_contexts) - else: - return lazy_contexts[0] - - -class MergedLazyContexts(AbstractLazyContext): - """data is a list of lazy contexts.""" - def infer(self): - return ContextSet.from_sets(l.infer() for l in self.data) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/param.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/param.py deleted file mode 100644 index a46394c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/param.py +++ /dev/null @@ -1,195 +0,0 @@ -from collections import defaultdict - -from jedi.evaluate.utils import PushBackIterator -from jedi.evaluate import analysis -from jedi.evaluate.lazy_context import LazyKnownContext, \ - LazyTreeContext, LazyUnknownContext -from jedi.evaluate import docstrings -from jedi.evaluate import pep0484 -from jedi.evaluate.context import iterable - - -def _add_argument_issue(parent_context, error_name, lazy_context, message): - if isinstance(lazy_context, LazyTreeContext): - node = lazy_context.data - if node.parent.type == 'argument': - node = node.parent - analysis.add(parent_context, error_name, node, message) - - -class ExecutedParam(object): - """Fake a param and give it values.""" - def __init__(self, execution_context, param_node, lazy_context): - self._execution_context = execution_context - self._param_node = param_node - self._lazy_context = lazy_context - self.string_name = param_node.name.value - - def infer(self): - pep0484_hints = pep0484.infer_param(self._execution_context, self._param_node) - doc_params = docstrings.infer_param(self._execution_context, self._param_node) - if pep0484_hints or doc_params: - return pep0484_hints | doc_params - - return self._lazy_context.infer() - - @property - def var_args(self): - return self._execution_context.var_args - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self.string_name) - - -def get_params(execution_context, var_args): - result_params = [] - param_dict = {} - funcdef = execution_context.tree_node - parent_context = execution_context.parent_context - - for param in funcdef.get_params(): - param_dict[param.name.value] = param - unpacked_va = list(var_args.unpack(funcdef)) - var_arg_iterator = PushBackIterator(iter(unpacked_va)) - - non_matching_keys = defaultdict(lambda: []) - keys_used = {} - keys_only = False - had_multiple_value_error = False - for param in funcdef.get_params(): - # The value and key can both be null. There, the defaults apply. - # args / kwargs will just be empty arrays / dicts, respectively. - # Wrong value count is just ignored. If you try to test cases that are - # not allowed in Python, Jedi will maybe not show any completions. - key, argument = next(var_arg_iterator, (None, None)) - while key is not None: - keys_only = True - try: - key_param = param_dict[key] - except KeyError: - non_matching_keys[key] = argument - else: - if key in keys_used: - had_multiple_value_error = True - m = ("TypeError: %s() got multiple values for keyword argument '%s'." - % (funcdef.name, key)) - for node in var_args.get_calling_nodes(): - analysis.add(parent_context, 'type-error-multiple-values', - node, message=m) - else: - keys_used[key] = ExecutedParam(execution_context, key_param, argument) - key, argument = next(var_arg_iterator, (None, None)) - - try: - result_params.append(keys_used[param.name.value]) - continue - except KeyError: - pass - - if param.star_count == 1: - # *args param - lazy_context_list = [] - if argument is not None: - lazy_context_list.append(argument) - for key, argument in var_arg_iterator: - # Iterate until a key argument is found. - if key: - var_arg_iterator.push_back((key, argument)) - break - lazy_context_list.append(argument) - seq = iterable.FakeSequence(execution_context.evaluator, 'tuple', lazy_context_list) - result_arg = LazyKnownContext(seq) - elif param.star_count == 2: - # **kwargs param - dct = iterable.FakeDict(execution_context.evaluator, dict(non_matching_keys)) - result_arg = LazyKnownContext(dct) - non_matching_keys = {} - else: - # normal param - if argument is None: - # No value: Return an empty container - if param.default is None: - result_arg = LazyUnknownContext() - if not keys_only: - for node in var_args.get_calling_nodes(): - m = _error_argument_count(funcdef, len(unpacked_va)) - analysis.add(parent_context, 'type-error-too-few-arguments', - node, message=m) - else: - result_arg = LazyTreeContext(parent_context, param.default) - else: - result_arg = argument - - result_params.append(ExecutedParam(execution_context, param, result_arg)) - if not isinstance(result_arg, LazyUnknownContext): - keys_used[param.name.value] = result_params[-1] - - if keys_only: - # All arguments should be handed over to the next function. It's not - # about the values inside, it's about the names. Jedi needs to now that - # there's nothing to find for certain names. - for k in set(param_dict) - set(keys_used): - param = param_dict[k] - - if not (non_matching_keys or had_multiple_value_error or - param.star_count or param.default): - # add a warning only if there's not another one. - for node in var_args.get_calling_nodes(): - m = _error_argument_count(funcdef, len(unpacked_va)) - analysis.add(parent_context, 'type-error-too-few-arguments', - node, message=m) - - for key, lazy_context in non_matching_keys.items(): - m = "TypeError: %s() got an unexpected keyword argument '%s'." \ - % (funcdef.name, key) - _add_argument_issue( - parent_context, - 'type-error-keyword-argument', - lazy_context, - message=m - ) - - remaining_arguments = list(var_arg_iterator) - if remaining_arguments: - m = _error_argument_count(funcdef, len(unpacked_va)) - # Just report an error for the first param that is not needed (like - # cPython). - first_key, lazy_context = remaining_arguments[0] - if var_args.get_calling_nodes(): - # There might not be a valid calling node so check for that first. - _add_argument_issue(parent_context, 'type-error-too-many-arguments', lazy_context, message=m) - return result_params - - -def _error_argument_count(funcdef, actual_count): - params = funcdef.get_params() - default_arguments = sum(1 for p in params if p.default or p.star_count) - - if default_arguments == 0: - before = 'exactly ' - else: - before = 'from %s to ' % (len(params) - default_arguments) - return ('TypeError: %s() takes %s%s arguments (%s given).' - % (funcdef.name, before, len(params), actual_count)) - - -def _create_default_param(execution_context, param): - if param.star_count == 1: - result_arg = LazyKnownContext( - iterable.FakeSequence(execution_context.evaluator, 'tuple', []) - ) - elif param.star_count == 2: - result_arg = LazyKnownContext( - iterable.FakeDict(execution_context.evaluator, {}) - ) - elif param.default is None: - result_arg = LazyUnknownContext() - else: - result_arg = LazyTreeContext(execution_context.parent_context, param.default) - return ExecutedParam(execution_context, param, result_arg) - - -def create_default_params(execution_context, funcdef): - return [_create_default_param(execution_context, p) - for p in funcdef.get_params()] - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/parser_cache.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/parser_cache.py deleted file mode 100644 index 84fe52d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/parser_cache.py +++ /dev/null @@ -1,6 +0,0 @@ -from jedi.evaluate.cache import evaluator_function_cache - - -@evaluator_function_cache() -def get_yield_exprs(evaluator, funcdef): - return list(funcdef.iter_yield_exprs()) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/pep0484.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/pep0484.py deleted file mode 100644 index 820f112..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/pep0484.py +++ /dev/null @@ -1,222 +0,0 @@ -""" -PEP 0484 ( https://www.python.org/dev/peps/pep-0484/ ) describes type hints -through function annotations. There is a strong suggestion in this document -that only the type of type hinting defined in PEP0484 should be allowed -as annotations in future python versions. - -The (initial / probably incomplete) implementation todo list for pep-0484: -v Function parameter annotations with builtin/custom type classes -v Function returntype annotations with builtin/custom type classes -v Function parameter annotations with strings (forward reference) -v Function return type annotations with strings (forward reference) -v Local variable type hints -v Assigned types: `Url = str\ndef get(url:Url) -> str:` -v Type hints in `with` statements -x Stub files support -x support `@no_type_check` and `@no_type_check_decorator` -x support for typing.cast() operator -x support for type hint comments for functions, `# type: (int, str) -> int`. - See comment from Guido https://github.com/davidhalter/jedi/issues/662 -""" - -import os -import re - -from parso import ParserSyntaxError -from parso.python import tree - -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate import compiled -from jedi.evaluate.base_context import NO_CONTEXTS, ContextSet -from jedi.evaluate.lazy_context import LazyTreeContext -from jedi.evaluate.context import ModuleContext -from jedi import debug -from jedi import _compatibility -from jedi import parser_utils - - -def _evaluate_for_annotation(context, annotation, index=None): - """ - Evaluates a string-node, looking for an annotation - If index is not None, the annotation is expected to be a tuple - and we're interested in that index - """ - if annotation is not None: - context_set = context.eval_node(_fix_forward_reference(context, annotation)) - if index is not None: - context_set = context_set.filter( - lambda context: context.array_type == 'tuple' \ - and len(list(context.py__iter__())) >= index - ).py__getitem__(index) - return context_set.execute_evaluated() - else: - return NO_CONTEXTS - - -def _fix_forward_reference(context, node): - evaled_nodes = context.eval_node(node) - if len(evaled_nodes) != 1: - debug.warning("Eval'ed typing index %s should lead to 1 object, " - " not %s" % (node, evaled_nodes)) - return node - evaled_node = list(evaled_nodes)[0] - if isinstance(evaled_node, compiled.CompiledObject) and \ - isinstance(evaled_node.obj, str): - try: - new_node = context.evaluator.grammar.parse( - _compatibility.unicode(evaled_node.obj), - start_symbol='eval_input', - error_recovery=False - ) - except ParserSyntaxError: - debug.warning('Annotation not parsed: %s' % evaled_node.obj) - return node - else: - module = node.get_root_node() - parser_utils.move(new_node, module.end_pos[0]) - new_node.parent = context.tree_node - return new_node - else: - return node - - -@evaluator_method_cache() -def infer_param(execution_context, param): - annotation = param.annotation - module_context = execution_context.get_root_context() - return _evaluate_for_annotation(module_context, annotation) - - -def py__annotations__(funcdef): - return_annotation = funcdef.annotation - if return_annotation: - dct = {'return': return_annotation} - else: - dct = {} - for function_param in funcdef.get_params(): - param_annotation = function_param.annotation - if param_annotation is not None: - dct[function_param.name.value] = param_annotation - return dct - - -@evaluator_method_cache() -def infer_return_types(function_context): - annotation = py__annotations__(function_context.tree_node).get("return", None) - module_context = function_context.get_root_context() - return _evaluate_for_annotation(module_context, annotation) - - -_typing_module = None - - -def _get_typing_replacement_module(grammar): - """ - The idea is to return our jedi replacement for the PEP-0484 typing module - as discussed at https://github.com/davidhalter/jedi/issues/663 - """ - global _typing_module - if _typing_module is None: - typing_path = \ - os.path.abspath(os.path.join(__file__, "../jedi_typing.py")) - with open(typing_path) as f: - code = _compatibility.unicode(f.read()) - _typing_module = grammar.parse(code) - return _typing_module - - -def py__getitem__(context, typ, node): - if not typ.get_root_context().name.string_name == "typing": - return None - # we assume that any class using [] in a module called - # "typing" with a name for which we have a replacement - # should be replaced by that class. This is not 100% - # airtight but I don't have a better idea to check that it's - # actually the PEP-0484 typing module and not some other - if node.type == "subscriptlist": - nodes = node.children[::2] # skip the commas - else: - nodes = [node] - del node - - nodes = [_fix_forward_reference(context, node) for node in nodes] - type_name = typ.name.string_name - - # hacked in Union and Optional, since it's hard to do nicely in parsed code - if type_name in ("Union", '_Union'): - # In Python 3.6 it's still called typing.Union but it's an instance - # called _Union. - return ContextSet.from_sets(context.eval_node(node) for node in nodes) - if type_name in ("Optional", '_Optional'): - # Here we have the same issue like in Union. Therefore we also need to - # check for the instance typing._Optional (Python 3.6). - return context.eval_node(nodes[0]) - - typing = ModuleContext( - context.evaluator, - module_node=_get_typing_replacement_module(context.evaluator.latest_grammar), - path=None - ) - factories = typing.py__getattribute__("factory") - assert len(factories) == 1 - factory = list(factories)[0] - assert factory - function_body_nodes = factory.tree_node.children[4].children - valid_classnames = set(child.name.value - for child in function_body_nodes - if isinstance(child, tree.Class)) - if type_name not in valid_classnames: - return None - compiled_classname = compiled.create(context.evaluator, type_name) - - from jedi.evaluate.context.iterable import FakeSequence - args = FakeSequence( - context.evaluator, - "tuple", - [LazyTreeContext(context, n) for n in nodes] - ) - - result = factory.execute_evaluated(compiled_classname, args) - return result - - -def find_type_from_comment_hint_for(context, node, name): - return _find_type_from_comment_hint(context, node, node.children[1], name) - - -def find_type_from_comment_hint_with(context, node, name): - assert len(node.children[1].children) == 3, \ - "Can only be here when children[1] is 'foo() as f'" - varlist = node.children[1].children[2] - return _find_type_from_comment_hint(context, node, varlist, name) - - -def find_type_from_comment_hint_assign(context, node, name): - return _find_type_from_comment_hint(context, node, node.children[0], name) - - -def _find_type_from_comment_hint(context, node, varlist, name): - index = None - if varlist.type in ("testlist_star_expr", "exprlist", "testlist"): - # something like "a, b = 1, 2" - index = 0 - for child in varlist.children: - if child == name: - break - if child.type == "operator": - continue - index += 1 - else: - return [] - - comment = parser_utils.get_following_comment_same_line(node) - if comment is None: - return [] - match = re.match(r"^#\s*type:\s*([^#]*)", comment) - if not match: - return [] - annotation = tree.String( - repr(str(match.group(1).strip())), - node.start_pos) - annotation.parent = node.parent - return _evaluate_for_annotation(context, annotation, index) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/project.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/project.py deleted file mode 100644 index b90f0f0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/project.py +++ /dev/null @@ -1,40 +0,0 @@ -import os -import sys - -from jedi.evaluate.sys_path import get_venv_path, detect_additional_paths -from jedi.cache import underscore_memoization - - -class Project(object): - def __init__(self, sys_path=None): - if sys_path is not None: - self._sys_path = sys_path - - venv = os.getenv('VIRTUAL_ENV') - if venv: - sys_path = get_venv_path(venv) - - if sys_path is None: - sys_path = sys.path - - base_sys_path = list(sys_path) - try: - base_sys_path.remove('') - except ValueError: - pass - - self._base_sys_path = base_sys_path - - def add_script_path(self, script_path): - self._script_path = script_path - - def add_evaluator(self, evaluator): - self._evaluator = evaluator - - @property - @underscore_memoization - def sys_path(self): - if self._script_path is None: - return self._base_sys_path - - return self._base_sys_path + detect_additional_paths(self._evaluator, self._script_path) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/recursion.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/recursion.py deleted file mode 100644 index e2f34a4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/recursion.py +++ /dev/null @@ -1,135 +0,0 @@ -""" -Recursions are the recipe of |jedi| to conquer Python code. However, someone -must stop recursions going mad. Some settings are here to make |jedi| stop at -the right time. You can read more about them :ref:`here `. - -Next to :mod:`jedi.evaluate.cache` this module also makes |jedi| not -thread-safe. Why? ``execution_recursion_decorator`` uses class variables to -count the function calls. - -.. _settings-recursion: - -Settings -~~~~~~~~~~ - -Recursion settings are important if you don't want extremly -recursive python code to go absolutely crazy. - -The default values are based on experiments while completing the |jedi| library -itself (inception!). But I don't think there's any other Python library that -uses recursion in a similarly extreme way. Completion should also be fast and -therefore the quality might not always be maximal. - -.. autodata:: recursion_limit -.. autodata:: total_function_execution_limit -.. autodata:: per_function_execution_limit -.. autodata:: per_function_recursion_limit -""" - -from contextlib import contextmanager - -from jedi import debug -from jedi.evaluate.base_context import NO_CONTEXTS - - -recursion_limit = 15 -""" -Like ``sys.getrecursionlimit()``, just for |jedi|. -""" -total_function_execution_limit = 200 -""" -This is a hard limit of how many non-builtin functions can be executed. -""" -per_function_execution_limit = 6 -""" -The maximal amount of times a specific function may be executed. -""" -per_function_recursion_limit = 2 -""" -A function may not be executed more than this number of times recursively. -""" - -class RecursionDetector(object): - def __init__(self): - self.pushed_nodes = [] - - -@contextmanager -def execution_allowed(evaluator, node): - """ - A decorator to detect recursions in statements. In a recursion a statement - at the same place, in the same module may not be executed two times. - """ - pushed_nodes = evaluator.recursion_detector.pushed_nodes - - if node in pushed_nodes: - debug.warning('catched stmt recursion: %s @%s', node, - node.start_pos) - yield False - else: - pushed_nodes.append(node) - yield True - pushed_nodes.pop() - - -def execution_recursion_decorator(default=NO_CONTEXTS): - def decorator(func): - def wrapper(execution, **kwargs): - detector = execution.evaluator.execution_recursion_detector - allowed = detector.push_execution(execution) - try: - if allowed: - result = default - else: - result = func(execution, **kwargs) - finally: - detector.pop_execution() - return result - return wrapper - return decorator - - -class ExecutionRecursionDetector(object): - """ - Catches recursions of executions. - """ - def __init__(self, evaluator): - self._evaluator = evaluator - - self._recursion_level = 0 - self._parent_execution_funcs = [] - self._funcdef_execution_counts = {} - self._execution_count = 0 - - def pop_execution(self): - self._parent_execution_funcs.pop() - self._recursion_level -= 1 - - def push_execution(self, execution): - funcdef = execution.tree_node - - # These two will be undone in pop_execution. - self._recursion_level += 1 - self._parent_execution_funcs.append(funcdef) - - module = execution.get_root_context() - if module == self._evaluator.BUILTINS: - # We have control over builtins so we know they are not recursing - # like crazy. Therefore we just let them execute always, because - # they usually just help a lot with getting good results. - return False - - if self._recursion_level > recursion_limit: - return True - - if self._execution_count >= total_function_execution_limit: - return True - self._execution_count += 1 - - if self._funcdef_execution_counts.setdefault(funcdef, 0) >= per_function_execution_limit: - return True - self._funcdef_execution_counts[funcdef] += 1 - - if self._parent_execution_funcs.count(funcdef) > per_function_recursion_limit: - return True - return False diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/site.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/site.py deleted file mode 100644 index bf884fa..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/site.py +++ /dev/null @@ -1,110 +0,0 @@ -"""An adapted copy of relevant site-packages functionality from Python stdlib. - -This file contains some functions related to handling site-packages in Python -with jedi-specific modifications: - -- the functions operate on sys_path argument rather than global sys.path - -- in .pth files "import ..." lines that allow execution of arbitrary code are - skipped to prevent code injection into jedi interpreter - -""" - -# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, -# 2011, 2012, 2013, 2014, 2015 Python Software Foundation; All Rights Reserved - -from __future__ import print_function - -import sys -import os - - -def makepath(*paths): - dir = os.path.join(*paths) - try: - dir = os.path.abspath(dir) - except OSError: - pass - return dir, os.path.normcase(dir) - - -def _init_pathinfo(sys_path): - """Return a set containing all existing directory entries from sys_path""" - d = set() - for dir in sys_path: - try: - if os.path.isdir(dir): - dir, dircase = makepath(dir) - d.add(dircase) - except TypeError: - continue - return d - - -def addpackage(sys_path, sitedir, name, known_paths): - """Process a .pth file within the site-packages directory: - For each line in the file, either combine it with sitedir to a path - and add that to known_paths, or execute it if it starts with 'import '. - """ - if known_paths is None: - known_paths = _init_pathinfo(sys_path) - reset = 1 - else: - reset = 0 - fullname = os.path.join(sitedir, name) - try: - f = open(fullname, "r") - except OSError: - return - with f: - for n, line in enumerate(f): - if line.startswith("#"): - continue - try: - if line.startswith(("import ", "import\t")): - # Change by immerrr: don't evaluate import lines to prevent - # code injection into jedi through pth files. - # - # exec(line) - continue - line = line.rstrip() - dir, dircase = makepath(sitedir, line) - if not dircase in known_paths and os.path.exists(dir): - sys_path.append(dir) - known_paths.add(dircase) - except Exception: - print("Error processing line {:d} of {}:\n".format(n+1, fullname), - file=sys.stderr) - import traceback - for record in traceback.format_exception(*sys.exc_info()): - for line in record.splitlines(): - print(' '+line, file=sys.stderr) - print("\nRemainder of file ignored", file=sys.stderr) - break - if reset: - known_paths = None - return known_paths - - -def addsitedir(sys_path, sitedir, known_paths=None): - """Add 'sitedir' argument to sys_path if missing and handle .pth files in - 'sitedir'""" - if known_paths is None: - known_paths = _init_pathinfo(sys_path) - reset = 1 - else: - reset = 0 - sitedir, sitedircase = makepath(sitedir) - if not sitedircase in known_paths: - sys_path.append(sitedir) # Add path component - known_paths.add(sitedircase) - try: - names = os.listdir(sitedir) - except OSError: - return - names = [name for name in names if name.endswith(".pth")] - for name in sorted(names): - addpackage(sys_path, sitedir, name, known_paths) - if reset: - known_paths = None - return known_paths diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/stdlib.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/stdlib.py deleted file mode 100644 index 259d692..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/stdlib.py +++ /dev/null @@ -1,325 +0,0 @@ -""" -Implementations of standard library functions, because it's not possible to -understand them with Jedi. - -To add a new implementation, create a function and add it to the -``_implemented`` dict at the bottom of this module. - -Note that this module exists only to implement very specific functionality in -the standard library. The usual way to understand the standard library is the -compiled module that returns the types for C-builtins. -""" -import collections -import re - -from jedi import debug -from jedi.evaluate.arguments import ValuesArguments -from jedi.evaluate import analysis -from jedi.evaluate import compiled -from jedi.evaluate.context.instance import InstanceFunctionExecution, \ - AbstractInstanceContext, CompiledInstance, BoundMethod, \ - AnonymousInstanceFunctionExecution -from jedi.evaluate.base_context import ContextualizedNode, \ - NO_CONTEXTS, ContextSet -from jedi.evaluate.context import ClassContext, ModuleContext -from jedi.evaluate.context import iterable -from jedi.evaluate.lazy_context import LazyTreeContext -from jedi.evaluate.syntax_tree import is_string - -# Now this is all part of fake tuples in Jedi. However super doesn't work on -# __init__ and __new__ doesn't work at all. So adding this to nametuples is -# just the easiest way. -_NAMEDTUPLE_INIT = """ - def __init__(_cls, {arg_list}): - 'A helper function for namedtuple.' - self.__iterable = ({arg_list}) - - def __iter__(self): - for i in self.__iterable: - yield i - - def __getitem__(self, y): - return self.__iterable[y] - -""" - - -class NotInStdLib(LookupError): - pass - - -def execute(evaluator, obj, arguments): - if isinstance(obj, BoundMethod): - raise NotInStdLib() - - try: - obj_name = obj.name.string_name - except AttributeError: - pass - else: - if obj.parent_context == evaluator.BUILTINS: - module_name = 'builtins' - elif isinstance(obj.parent_context, ModuleContext): - module_name = obj.parent_context.name.string_name - else: - module_name = '' - - # for now we just support builtin functions. - try: - func = _implemented[module_name][obj_name] - except KeyError: - pass - else: - return func(evaluator, obj, arguments) - raise NotInStdLib() - - -def _follow_param(evaluator, arguments, index): - try: - key, lazy_context = list(arguments.unpack())[index] - except IndexError: - return NO_CONTEXTS - else: - return lazy_context.infer() - - -def argument_clinic(string, want_obj=False, want_context=False, want_arguments=False): - """ - Works like Argument Clinic (PEP 436), to validate function params. - """ - clinic_args = [] - allow_kwargs = False - optional = False - while string: - # Optional arguments have to begin with a bracket. And should always be - # at the end of the arguments. This is therefore not a proper argument - # clinic implementation. `range()` for exmple allows an optional start - # value at the beginning. - match = re.match('(?:(?:(\[),? ?|, ?|)(\w+)|, ?/)\]*', string) - string = string[len(match.group(0)):] - if not match.group(2): # A slash -> allow named arguments - allow_kwargs = True - continue - optional = optional or bool(match.group(1)) - word = match.group(2) - clinic_args.append((word, optional, allow_kwargs)) - - def f(func): - def wrapper(evaluator, obj, arguments): - debug.dbg('builtin start %s' % obj, color='MAGENTA') - try: - lst = list(arguments.eval_argument_clinic(clinic_args)) - except ValueError: - return NO_CONTEXTS - else: - kwargs = {} - if want_context: - kwargs['context'] = arguments.context - if want_obj: - kwargs['obj'] = obj - if want_arguments: - kwargs['arguments'] = arguments - return func(evaluator, *lst, **kwargs) - finally: - debug.dbg('builtin end', color='MAGENTA') - - return wrapper - return f - - -@argument_clinic('iterator[, default], /') -def builtins_next(evaluator, iterators, defaults): - """ - TODO this function is currently not used. It's a stab at implementing next - in a different way than fake objects. This would be a bit more flexible. - """ - if evaluator.python_version[0] == 2: - name = 'next' - else: - name = '__next__' - - context_set = NO_CONTEXTS - for iterator in iterators: - if isinstance(iterator, AbstractInstanceContext): - context_set = ContextSet.from_sets( - n.infer() - for filter in iterator.get_filters(include_self_names=True) - for n in filter.get(name) - ).execute_evaluated() - if context_set: - return context_set - return defaults - - -@argument_clinic('object, name[, default], /') -def builtins_getattr(evaluator, objects, names, defaults=None): - # follow the first param - for obj in objects: - for name in names: - if is_string(name): - return obj.py__getattribute__(name.obj) - else: - debug.warning('getattr called without str') - continue - return NO_CONTEXTS - - -@argument_clinic('object[, bases, dict], /') -def builtins_type(evaluator, objects, bases, dicts): - if bases or dicts: - # It's a type creation... maybe someday... - return NO_CONTEXTS - else: - return objects.py__class__() - - -class SuperInstance(AbstractInstanceContext): - """To be used like the object ``super`` returns.""" - def __init__(self, evaluator, cls): - su = cls.py_mro()[1] - super().__init__(evaluator, su and su[0] or self) - - -@argument_clinic('[type[, obj]], /', want_context=True) -def builtins_super(evaluator, types, objects, context): - # TODO make this able to detect multiple inheritance super - if isinstance(context, (InstanceFunctionExecution, - AnonymousInstanceFunctionExecution)): - su = context.instance.py__class__().py__bases__() - return su[0].infer().execute_evaluated() - return NO_CONTEXTS - - -@argument_clinic('sequence, /', want_obj=True, want_arguments=True) -def builtins_reversed(evaluator, sequences, obj, arguments): - # While we could do without this variable (just by using sequences), we - # want static analysis to work well. Therefore we need to generated the - # values again. - key, lazy_context = next(arguments.unpack()) - cn = None - if isinstance(lazy_context, LazyTreeContext): - # TODO access private - cn = ContextualizedNode(lazy_context._context, lazy_context.data) - ordered = list(sequences.iterate(cn)) - - rev = list(reversed(ordered)) - # Repack iterator values and then run it the normal way. This is - # necessary, because `reversed` is a function and autocompletion - # would fail in certain cases like `reversed(x).__iter__` if we - # just returned the result directly. - seq = iterable.FakeSequence(evaluator, 'list', rev) - arguments = ValuesArguments([ContextSet(seq)]) - return ContextSet(CompiledInstance(evaluator, evaluator.BUILTINS, obj, arguments)) - - -@argument_clinic('obj, type, /', want_arguments=True) -def builtins_isinstance(evaluator, objects, types, arguments): - bool_results = set() - for o in objects: - try: - mro_func = o.py__class__().py__mro__ - except AttributeError: - # This is temporary. Everything should have a class attribute in - # Python?! Maybe we'll leave it here, because some numpy objects or - # whatever might not. - return ContextSet(compiled.create(True), compiled.create(False)) - - mro = mro_func() - - for cls_or_tup in types: - if cls_or_tup.is_class(): - bool_results.add(cls_or_tup in mro) - elif cls_or_tup.name.string_name == 'tuple' \ - and cls_or_tup.get_root_context() == evaluator.BUILTINS: - # Check for tuples. - classes = ContextSet.from_sets( - lazy_context.infer() - for lazy_context in cls_or_tup.iterate() - ) - bool_results.add(any(cls in mro for cls in classes)) - else: - _, lazy_context = list(arguments.unpack())[1] - if isinstance(lazy_context, LazyTreeContext): - node = lazy_context.data - message = 'TypeError: isinstance() arg 2 must be a ' \ - 'class, type, or tuple of classes and types, ' \ - 'not %s.' % cls_or_tup - analysis.add(lazy_context._context, 'type-error-isinstance', node, message) - - return ContextSet.from_iterable(compiled.create(evaluator, x) for x in bool_results) - - -def collections_namedtuple(evaluator, obj, arguments): - """ - Implementation of the namedtuple function. - - This has to be done by processing the namedtuple class template and - evaluating the result. - - .. note:: |jedi| only supports namedtuples on Python >2.6. - - """ - # Namedtuples are not supported on Python 2.6 - if not hasattr(collections, '_class_template'): - return NO_CONTEXTS - - # Process arguments - # TODO here we only use one of the types, we should use all. - name = list(_follow_param(evaluator, arguments, 0))[0].obj - _fields = list(_follow_param(evaluator, arguments, 1))[0] - if isinstance(_fields, compiled.CompiledObject): - fields = _fields.obj.replace(',', ' ').split() - elif isinstance(_fields, iterable.AbstractIterable): - fields = [ - v.obj - for lazy_context in _fields.py__iter__() - for v in lazy_context.infer() if hasattr(v, 'obj') - ] - else: - return NO_CONTEXTS - - base = collections._class_template - base += _NAMEDTUPLE_INIT - # Build source - source = base.format( - typename=name, - field_names=tuple(fields), - num_fields=len(fields), - arg_list = repr(tuple(fields)).replace("'", "")[1:-1], - repr_fmt=', '.join(collections._repr_template.format(name=name) for name in fields), - field_defs='\n'.join(collections._field_template.format(index=index, name=name) - for index, name in enumerate(fields)) - ) - - # Parse source - module = evaluator.grammar.parse(source) - generated_class = next(module.iter_classdefs()) - parent_context = ModuleContext(evaluator, module, '') - return ContextSet(ClassContext(evaluator, parent_context, generated_class)) - - -@argument_clinic('first, /') -def _return_first_param(evaluator, firsts): - return firsts - - -_implemented = { - 'builtins': { - 'getattr': builtins_getattr, - 'type': builtins_type, - 'super': builtins_super, - 'reversed': builtins_reversed, - 'isinstance': builtins_isinstance, - }, - 'copy': { - 'copy': _return_first_param, - 'deepcopy': _return_first_param, - }, - 'json': { - 'load': lambda *args: NO_CONTEXTS, - 'loads': lambda *args: NO_CONTEXTS, - }, - 'collections': { - 'namedtuple': collections_namedtuple, - }, -} diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/syntax_tree.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/syntax_tree.py deleted file mode 100644 index 1d847a4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/syntax_tree.py +++ /dev/null @@ -1,588 +0,0 @@ -""" -Functions evaluating the syntax tree. -""" -import copy -import operator as op - -from parso.python import tree - -from jedi import debug -from jedi import parser_utils -from jedi.evaluate.base_context import ContextSet, NO_CONTEXTS, ContextualizedNode, \ - ContextualizedName, iterator_to_context_set, iterate_contexts -from jedi.evaluate import compiled -from jedi.evaluate import pep0484 -from jedi.evaluate import recursion -from jedi.evaluate import helpers -from jedi.evaluate import analysis -from jedi.evaluate import imports -from jedi.evaluate import arguments -from jedi.evaluate.context import ClassContext, FunctionContext -from jedi.evaluate.context import iterable -from jedi.evaluate.context import TreeInstance, CompiledInstance -from jedi.evaluate.finder import NameFinder -from jedi.evaluate.helpers import is_string, is_literal, is_number, is_compiled - - -def _limit_context_infers(func): - """ - This is for now the way how we limit type inference going wild. There are - other ways to ensure recursion limits as well. This is mostly necessary - because of instance (self) access that can be quite tricky to limit. - - I'm still not sure this is the way to go, but it looks okay for now and we - can still go anther way in the future. Tests are there. ~ dave - """ - def wrapper(context, *args, **kwargs): - n = context.tree_node - evaluator = context.evaluator - try: - evaluator.inferred_element_counts[n] += 1 - if evaluator.inferred_element_counts[n] > 300: - debug.warning('In context %s there were too many inferences.', n) - return NO_CONTEXTS - except KeyError: - evaluator.inferred_element_counts[n] = 1 - return func(context, *args, **kwargs) - - return wrapper - - -@debug.increase_indent -@_limit_context_infers -def eval_node(context, element): - debug.dbg('eval_element %s@%s', element, element.start_pos) - evaluator = context.evaluator - typ = element.type - if typ in ('name', 'number', 'string', 'atom'): - return eval_atom(context, element) - elif typ == 'keyword': - # For False/True/None - if element.value in ('False', 'True', 'None'): - return ContextSet(compiled.builtin_from_name(evaluator, element.value)) - # else: print e.g. could be evaluated like this in Python 2.7 - return NO_CONTEXTS - elif typ == 'lambdef': - return ContextSet(FunctionContext(evaluator, context, element)) - elif typ == 'expr_stmt': - return eval_expr_stmt(context, element) - elif typ in ('power', 'atom_expr'): - first_child = element.children[0] - if not (first_child.type == 'keyword' and first_child.value == 'await'): - context_set = eval_atom(context, first_child) - for trailer in element.children[1:]: - if trailer == '**': # has a power operation. - right = evaluator.eval_element(context, element.children[2]) - context_set = _eval_comparison( - evaluator, - context, - context_set, - trailer, - right - ) - break - context_set = eval_trailer(context, context_set, trailer) - return context_set - return NO_CONTEXTS - elif typ in ('testlist_star_expr', 'testlist',): - # The implicit tuple in statements. - return ContextSet(iterable.SequenceLiteralContext(evaluator, context, element)) - elif typ in ('not_test', 'factor'): - context_set = context.eval_node(element.children[-1]) - for operator in element.children[:-1]: - context_set = eval_factor(context_set, operator) - return context_set - elif typ == 'test': - # `x if foo else y` case. - return (context.eval_node(element.children[0]) | - context.eval_node(element.children[-1])) - elif typ == 'operator': - # Must be an ellipsis, other operators are not evaluated. - # In Python 2 ellipsis is coded as three single dot tokens, not - # as one token 3 dot token. - assert element.value in ('.', '...') - return ContextSet(compiled.create(evaluator, Ellipsis)) - elif typ == 'dotted_name': - context_set = eval_atom(context, element.children[0]) - for next_name in element.children[2::2]: - # TODO add search_global=True? - context_set = context_set.py__getattribute__(next_name, name_context=context) - return context_set - elif typ == 'eval_input': - return eval_node(context, element.children[0]) - elif typ == 'annassign': - return pep0484._evaluate_for_annotation(context, element.children[1]) - else: - return eval_or_test(context, element) - - -def eval_trailer(context, base_contexts, trailer): - trailer_op, node = trailer.children[:2] - if node == ')': # `arglist` is optional. - node = () - - if trailer_op == '[': - trailer_op, node, _ = trailer.children - - # TODO It's kind of stupid to cast this from a context set to a set. - foo = set(base_contexts) - # special case: PEP0484 typing module, see - # https://github.com/davidhalter/jedi/issues/663 - result = ContextSet() - for typ in list(foo): - if isinstance(typ, (ClassContext, TreeInstance)): - typing_module_types = pep0484.py__getitem__(context, typ, node) - if typing_module_types is not None: - foo.remove(typ) - result |= typing_module_types - - return result | base_contexts.get_item( - eval_subscript_list(context.evaluator, context, node), - ContextualizedNode(context, trailer) - ) - else: - debug.dbg('eval_trailer: %s in %s', trailer, base_contexts) - if trailer_op == '.': - return base_contexts.py__getattribute__( - name_context=context, - name_or_str=node - ) - else: - assert trailer_op == '(' - args = arguments.TreeArguments(context.evaluator, context, node, trailer) - return base_contexts.execute(args) - - -def eval_atom(context, atom): - """ - Basically to process ``atom`` nodes. The parser sometimes doesn't - generate the node (because it has just one child). In that case an atom - might be a name or a literal as well. - """ - if atom.type == 'name': - # This is the first global lookup. - stmt = tree.search_ancestor( - atom, 'expr_stmt', 'lambdef' - ) or atom - if stmt.type == 'lambdef': - stmt = atom - return context.py__getattribute__( - name_or_str=atom, - position=stmt.start_pos, - search_global=True - ) - - elif isinstance(atom, tree.Literal): - string = parser_utils.safe_literal_eval(atom.value) - return ContextSet(compiled.create(context.evaluator, string)) - else: - c = atom.children - if c[0].type == 'string': - # Will be one string. - context_set = eval_atom(context, c[0]) - for string in c[1:]: - right = eval_atom(context, string) - context_set = _eval_comparison(context.evaluator, context, context_set, '+', right) - return context_set - # Parentheses without commas are not tuples. - elif c[0] == '(' and not len(c) == 2 \ - and not(c[1].type == 'testlist_comp' and - len(c[1].children) > 1): - return context.eval_node(c[1]) - - try: - comp_for = c[1].children[1] - except (IndexError, AttributeError): - pass - else: - if comp_for == ':': - # Dict comprehensions have a colon at the 3rd index. - try: - comp_for = c[1].children[3] - except IndexError: - pass - - if comp_for.type == 'comp_for': - return ContextSet(iterable.Comprehension.from_atom(context.evaluator, context, atom)) - - # It's a dict/list/tuple literal. - array_node = c[1] - try: - array_node_c = array_node.children - except AttributeError: - array_node_c = [] - if c[0] == '{' and (array_node == '}' or ':' in array_node_c): - context = iterable.DictLiteralContext(context.evaluator, context, atom) - else: - context = iterable.SequenceLiteralContext(context.evaluator, context, atom) - return ContextSet(context) - - -@_limit_context_infers -def eval_expr_stmt(context, stmt, seek_name=None): - with recursion.execution_allowed(context.evaluator, stmt) as allowed: - if allowed or context.get_root_context() == context.evaluator.BUILTINS: - return _eval_expr_stmt(context, stmt, seek_name) - return NO_CONTEXTS - - -@debug.increase_indent -def _eval_expr_stmt(context, stmt, seek_name=None): - """ - The starting point of the completion. A statement always owns a call - list, which are the calls, that a statement does. In case multiple - names are defined in the statement, `seek_name` returns the result for - this name. - - :param stmt: A `tree.ExprStmt`. - """ - debug.dbg('eval_expr_stmt %s (%s)', stmt, seek_name) - rhs = stmt.get_rhs() - context_set = context.eval_node(rhs) - - if seek_name: - c_node = ContextualizedName(context, seek_name) - context_set = check_tuple_assignments(context.evaluator, c_node, context_set) - - first_operator = next(stmt.yield_operators(), None) - if first_operator not in ('=', None) and first_operator.type == 'operator': - # `=` is always the last character in aug assignments -> -1 - operator = copy.copy(first_operator) - operator.value = operator.value[:-1] - name = stmt.get_defined_names()[0].value - left = context.py__getattribute__( - name, position=stmt.start_pos, search_global=True) - - for_stmt = tree.search_ancestor(stmt, 'for_stmt') - if for_stmt is not None and for_stmt.type == 'for_stmt' and context_set \ - and parser_utils.for_stmt_defines_one_name(for_stmt): - # Iterate through result and add the values, that's possible - # only in for loops without clutter, because they are - # predictable. Also only do it, if the variable is not a tuple. - node = for_stmt.get_testlist() - cn = ContextualizedNode(context, node) - ordered = list(cn.infer().iterate(cn)) - - for lazy_context in ordered: - dct = {for_stmt.children[1].value: lazy_context.infer()} - with helpers.predefine_names(context, for_stmt, dct): - t = context.eval_node(rhs) - left = _eval_comparison(context.evaluator, context, left, operator, t) - context_set = left - else: - context_set = _eval_comparison(context.evaluator, context, left, operator, context_set) - debug.dbg('eval_expr_stmt result %s', context_set) - return context_set - - -def eval_or_test(context, or_test): - iterator = iter(or_test.children) - types = context.eval_node(next(iterator)) - for operator in iterator: - right = next(iterator) - if operator.type == 'comp_op': # not in / is not - operator = ' '.join(c.value for c in operator.children) - - # handle lazy evaluation of and/or here. - if operator in ('and', 'or'): - left_bools = set(left.py__bool__() for left in types) - if left_bools == set([True]): - if operator == 'and': - types = context.eval_node(right) - elif left_bools == set([False]): - if operator != 'and': - types = context.eval_node(right) - # Otherwise continue, because of uncertainty. - else: - types = _eval_comparison(context.evaluator, context, types, operator, - context.eval_node(right)) - debug.dbg('eval_or_test types %s', types) - return types - - -@iterator_to_context_set -def eval_factor(context_set, operator): - """ - Calculates `+`, `-`, `~` and `not` prefixes. - """ - for context in context_set: - if operator == '-': - if is_number(context): - yield compiled.create(context.evaluator, -context.obj) - elif operator == 'not': - value = context.py__bool__() - if value is None: # Uncertainty. - return - yield compiled.create(context.evaluator, not value) - else: - yield context - - -# Maps Python syntax to the operator module. -COMPARISON_OPERATORS = { - '==': op.eq, - '!=': op.ne, - 'is': op.is_, - 'is not': op.is_not, - '<': op.lt, - '<=': op.le, - '>': op.gt, - '>=': op.ge, -} - - -def _literals_to_types(evaluator, result): - # Changes literals ('a', 1, 1.0, etc) to its type instances (str(), - # int(), float(), etc). - new_result = NO_CONTEXTS - for typ in result: - if is_literal(typ): - # Literals are only valid as long as the operations are - # correct. Otherwise add a value-free instance. - cls = compiled.builtin_from_name(evaluator, typ.name.string_name) - new_result |= cls.execute_evaluated() - else: - new_result |= ContextSet(typ) - return new_result - - -def _eval_comparison(evaluator, context, left_contexts, operator, right_contexts): - if not left_contexts or not right_contexts: - # illegal slices e.g. cause left/right_result to be None - result = (left_contexts or NO_CONTEXTS) | (right_contexts or NO_CONTEXTS) - return _literals_to_types(evaluator, result) - else: - # I don't think there's a reasonable chance that a string - # operation is still correct, once we pass something like six - # objects. - if len(left_contexts) * len(right_contexts) > 6: - return _literals_to_types(evaluator, left_contexts | right_contexts) - else: - return ContextSet.from_sets( - _eval_comparison_part(evaluator, context, left, operator, right) - for left in left_contexts - for right in right_contexts - ) - - -def _is_tuple(context): - return isinstance(context, iterable.AbstractIterable) and context.array_type == 'tuple' - - -def _is_list(context): - return isinstance(context, iterable.AbstractIterable) and context.array_type == 'list' - - -def _eval_comparison_part(evaluator, context, left, operator, right): - l_is_num = is_number(left) - r_is_num = is_number(right) - if operator == '*': - # for iterables, ignore * operations - if isinstance(left, iterable.AbstractIterable) or is_string(left): - return ContextSet(left) - elif isinstance(right, iterable.AbstractIterable) or is_string(right): - return ContextSet(right) - elif operator == '+': - if l_is_num and r_is_num or is_string(left) and is_string(right): - return ContextSet(compiled.create(evaluator, left.obj + right.obj)) - elif _is_tuple(left) and _is_tuple(right) or _is_list(left) and _is_list(right): - return ContextSet(iterable.MergedArray(evaluator, (left, right))) - elif operator == '-': - if l_is_num and r_is_num: - return ContextSet(compiled.create(evaluator, left.obj - right.obj)) - elif operator == '%': - # With strings and numbers the left type typically remains. Except for - # `int() % float()`. - return ContextSet(left) - elif operator in COMPARISON_OPERATORS: - operation = COMPARISON_OPERATORS[operator] - if is_compiled(left) and is_compiled(right): - # Possible, because the return is not an option. Just compare. - left = left.obj - right = right.obj - - try: - result = operation(left, right) - except TypeError: - # Could be True or False. - return ContextSet(compiled.create(evaluator, True), compiled.create(evaluator, False)) - else: - return ContextSet(compiled.create(evaluator, result)) - elif operator == 'in': - return NO_CONTEXTS - - def check(obj): - """Checks if a Jedi object is either a float or an int.""" - return isinstance(obj, CompiledInstance) and \ - obj.name.string_name in ('int', 'float') - - # Static analysis, one is a number, the other one is not. - if operator in ('+', '-') and l_is_num != r_is_num \ - and not (check(left) or check(right)): - message = "TypeError: unsupported operand type(s) for +: %s and %s" - analysis.add(context, 'type-error-operation', operator, - message % (left, right)) - - return ContextSet(left, right) - - -def _remove_statements(evaluator, context, stmt, name): - """ - This is the part where statements are being stripped. - - Due to lazy evaluation, statements like a = func; b = a; b() have to be - evaluated. - """ - pep0484_contexts = \ - pep0484.find_type_from_comment_hint_assign(context, stmt, name) - if pep0484_contexts: - return pep0484_contexts - - return eval_expr_stmt(context, stmt, seek_name=name) - - -def tree_name_to_contexts(evaluator, context, tree_name): - types = [] - node = tree_name.get_definition(import_name_always=True) - if node is None: - node = tree_name.parent - if node.type == 'global_stmt': - context = evaluator.create_context(context, tree_name) - finder = NameFinder(evaluator, context, context, tree_name.value) - filters = finder.get_filters(search_global=True) - # For global_stmt lookups, we only need the first possible scope, - # which means the function itself. - filters = [next(filters)] - return finder.find(filters, attribute_lookup=False) - elif node.type not in ('import_from', 'import_name'): - raise ValueError("Should not happen.") - - typ = node.type - if typ == 'for_stmt': - types = pep0484.find_type_from_comment_hint_for(context, node, tree_name) - if types: - return types - if typ == 'with_stmt': - types = pep0484.find_type_from_comment_hint_with(context, node, tree_name) - if types: - return types - - if typ in ('for_stmt', 'comp_for'): - try: - types = context.predefined_names[node][tree_name.value] - except KeyError: - cn = ContextualizedNode(context, node.children[3]) - for_types = iterate_contexts(cn.infer(), cn) - c_node = ContextualizedName(context, tree_name) - types = check_tuple_assignments(evaluator, c_node, for_types) - elif typ == 'expr_stmt': - types = _remove_statements(evaluator, context, node, tree_name) - elif typ == 'with_stmt': - context_managers = context.eval_node(node.get_test_node_from_name(tree_name)) - enter_methods = context_managers.py__getattribute__('__enter__') - return enter_methods.execute_evaluated() - elif typ in ('import_from', 'import_name'): - types = imports.infer_import(context, tree_name) - elif typ in ('funcdef', 'classdef'): - types = _apply_decorators(context, node) - elif typ == 'try_stmt': - # TODO an exception can also be a tuple. Check for those. - # TODO check for types that are not classes and add it to - # the static analysis report. - exceptions = context.eval_node(tree_name.get_previous_sibling().get_previous_sibling()) - types = exceptions.execute_evaluated() - else: - raise ValueError("Should not happen.") - return types - - -def _apply_decorators(context, node): - """ - Returns the function, that should to be executed in the end. - This is also the places where the decorators are processed. - """ - if node.type == 'classdef': - decoratee_context = ClassContext( - context.evaluator, - parent_context=context, - classdef=node - ) - else: - decoratee_context = FunctionContext( - context.evaluator, - parent_context=context, - funcdef=node - ) - initial = values = ContextSet(decoratee_context) - for dec in reversed(node.get_decorators()): - debug.dbg('decorator: %s %s', dec, values) - dec_values = context.eval_node(dec.children[1]) - trailer_nodes = dec.children[2:-1] - if trailer_nodes: - # Create a trailer and evaluate it. - trailer = tree.PythonNode('trailer', trailer_nodes) - trailer.parent = dec - dec_values = eval_trailer(context, dec_values, trailer) - - if not len(dec_values): - debug.warning('decorator not found: %s on %s', dec, node) - return initial - - values = dec_values.execute(arguments.ValuesArguments([values])) - if not len(values): - debug.warning('not possible to resolve wrappers found %s', node) - return initial - - debug.dbg('decorator end %s', values) - return values - - -def check_tuple_assignments(evaluator, contextualized_name, context_set): - """ - Checks if tuples are assigned. - """ - lazy_context = None - for index, node in contextualized_name.assignment_indexes(): - cn = ContextualizedNode(contextualized_name.context, node) - iterated = context_set.iterate(cn) - for _ in range(index + 1): - try: - lazy_context = next(iterated) - except StopIteration: - # We could do this with the default param in next. But this - # would allow this loop to run for a very long time if the - # index number is high. Therefore break if the loop is - # finished. - return ContextSet() - context_set = lazy_context.infer() - return context_set - - -def eval_subscript_list(evaluator, context, index): - """ - Handles slices in subscript nodes. - """ - if index == ':': - # Like array[:] - return ContextSet(iterable.Slice(context, None, None, None)) - - elif index.type == 'subscript' and not index.children[0] == '.': - # subscript basically implies a slice operation, except for Python 2's - # Ellipsis. - # e.g. array[:3] - result = [] - for el in index.children: - if el == ':': - if not result: - result.append(None) - elif el.type == 'sliceop': - if len(el.children) == 2: - result.append(el.children[1]) - else: - result.append(el) - result += [None] * (3 - len(result)) - - return ContextSet(iterable.Slice(context, *result)) - - # No slices - return context.eval_node(index) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/sys_path.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/sys_path.py deleted file mode 100644 index 82e5e9d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/sys_path.py +++ /dev/null @@ -1,308 +0,0 @@ -import glob -import os -import sys -import imp -from jedi.evaluate.site import addsitedir - -from jedi._compatibility import unicode -from jedi.evaluate.cache import evaluator_method_cache -from jedi.evaluate.base_context import ContextualizedNode -from jedi.evaluate.helpers import is_string -from jedi import settings -from jedi import debug -from jedi.evaluate.utils import ignored - - -def get_venv_path(venv): - """Get sys.path for specified virtual environment.""" - sys_path = _get_venv_path_dirs(venv) - with ignored(ValueError): - sys_path.remove('') - sys_path = _get_sys_path_with_egglinks(sys_path) - # As of now, get_venv_path_dirs does not scan built-in pythonpath and - # user-local site-packages, let's approximate them using path from Jedi - # interpreter. - return sys_path + sys.path - - -def _get_sys_path_with_egglinks(sys_path): - """Find all paths including those referenced by egg-links. - - Egg-link-referenced directories are inserted into path immediately before - the directory on which their links were found. Such directories are not - taken into consideration by normal import mechanism, but they are traversed - when doing pkg_resources.require. - """ - result = [] - for p in sys_path: - # pkg_resources does not define a specific order for egg-link files - # using os.listdir to enumerate them, we're sorting them to have - # reproducible tests. - for egg_link in sorted(glob.glob(os.path.join(p, '*.egg-link'))): - with open(egg_link) as fd: - for line in fd: - line = line.strip() - if line: - result.append(os.path.join(p, line)) - # pkg_resources package only interprets the first - # non-empty line in egg-link files. - break - result.append(p) - return result - - -def _get_venv_path_dirs(venv): - """Get sys.path for venv without starting up the interpreter.""" - venv = os.path.abspath(venv) - sitedir = _get_venv_sitepackages(venv) - sys_path = [] - addsitedir(sys_path, sitedir) - return sys_path - - -def _get_venv_sitepackages(venv): - if os.name == 'nt': - p = os.path.join(venv, 'lib', 'site-packages') - else: - p = os.path.join(venv, 'lib', 'python%d.%d' % sys.version_info[:2], - 'site-packages') - return p - - -def _abs_path(module_context, path): - module_path = module_context.py__file__() - if os.path.isabs(path): - return path - - if module_path is None: - # In this case we have no idea where we actually are in the file - # system. - return None - - base_dir = os.path.dirname(module_path) - return os.path.abspath(os.path.join(base_dir, path)) - - -def _paths_from_assignment(module_context, expr_stmt): - """ - Extracts the assigned strings from an assignment that looks as follows:: - - >>> sys.path[0:0] = ['module/path', 'another/module/path'] - - This function is in general pretty tolerant (and therefore 'buggy'). - However, it's not a big issue usually to add more paths to Jedi's sys_path, - because it will only affect Jedi in very random situations and by adding - more paths than necessary, it usually benefits the general user. - """ - for assignee, operator in zip(expr_stmt.children[::2], expr_stmt.children[1::2]): - try: - assert operator in ['=', '+='] - assert assignee.type in ('power', 'atom_expr') and \ - len(assignee.children) > 1 - c = assignee.children - assert c[0].type == 'name' and c[0].value == 'sys' - trailer = c[1] - assert trailer.children[0] == '.' and trailer.children[1].value == 'path' - # TODO Essentially we're not checking details on sys.path - # manipulation. Both assigment of the sys.path and changing/adding - # parts of the sys.path are the same: They get added to the end of - # the current sys.path. - """ - execution = c[2] - assert execution.children[0] == '[' - subscript = execution.children[1] - assert subscript.type == 'subscript' - assert ':' in subscript.children - """ - except AssertionError: - continue - - cn = ContextualizedNode(module_context.create_context(expr_stmt), expr_stmt) - for lazy_context in cn.infer().iterate(cn): - for context in lazy_context.infer(): - if is_string(context): - abs_path = _abs_path(module_context, context.obj) - if abs_path is not None: - yield abs_path - - -def _paths_from_list_modifications(module_context, trailer1, trailer2): - """ extract the path from either "sys.path.append" or "sys.path.insert" """ - # Guarantee that both are trailers, the first one a name and the second one - # a function execution with at least one param. - if not (trailer1.type == 'trailer' and trailer1.children[0] == '.' - and trailer2.type == 'trailer' and trailer2.children[0] == '(' - and len(trailer2.children) == 3): - return - - name = trailer1.children[1].value - if name not in ['insert', 'append']: - return - arg = trailer2.children[1] - if name == 'insert' and len(arg.children) in (3, 4): # Possible trailing comma. - arg = arg.children[2] - - for context in module_context.create_context(arg).eval_node(arg): - if is_string(context): - abs_path = _abs_path(module_context, context.obj) - if abs_path is not None: - yield abs_path - - -@evaluator_method_cache(default=[]) -def check_sys_path_modifications(module_context): - """ - Detect sys.path modifications within module. - """ - def get_sys_path_powers(names): - for name in names: - power = name.parent.parent - if power.type in ('power', 'atom_expr'): - c = power.children - if c[0].type == 'name' and c[0].value == 'sys' \ - and c[1].type == 'trailer': - n = c[1].children[1] - if n.type == 'name' and n.value == 'path': - yield name, power - - if module_context.tree_node is None: - return [] - - added = [] - try: - possible_names = module_context.tree_node.get_used_names()['path'] - except KeyError: - pass - else: - for name, power in get_sys_path_powers(possible_names): - expr_stmt = power.parent - if len(power.children) >= 4: - added.extend( - _paths_from_list_modifications( - module_context, *power.children[2:4] - ) - ) - elif expr_stmt is not None and expr_stmt.type == 'expr_stmt': - added.extend(_paths_from_assignment(module_context, expr_stmt)) - return added - - -def sys_path_with_modifications(evaluator, module_context): - return evaluator.project.sys_path + check_sys_path_modifications(module_context) - - -def detect_additional_paths(evaluator, script_path): - django_paths = _detect_django_path(script_path) - buildout_script_paths = set() - - for buildout_script_path in _get_buildout_script_paths(script_path): - for path in _get_paths_from_buildout_script(evaluator, buildout_script_path): - buildout_script_paths.add(path) - - return django_paths + list(buildout_script_paths) - - -def _get_paths_from_buildout_script(evaluator, buildout_script_path): - try: - module_node = evaluator.grammar.parse( - path=buildout_script_path, - cache=True, - cache_path=settings.cache_directory - ) - except IOError: - debug.warning('Error trying to read buildout_script: %s', buildout_script_path) - return - - from jedi.evaluate.context import ModuleContext - module = ModuleContext(evaluator, module_node, buildout_script_path) - for path in check_sys_path_modifications(module): - yield path - - -def traverse_parents(path): - while True: - new = os.path.dirname(path) - if new == path: - return - path = new - yield path - - -def _get_parent_dir_with_file(path, filename): - for parent in traverse_parents(path): - if os.path.isfile(os.path.join(parent, filename)): - return parent - return None - - -def _detect_django_path(module_path): - """ Detects the path of the very well known Django library (if used) """ - result = [] - - for parent in traverse_parents(module_path): - with ignored(IOError): - with open(parent + os.path.sep + 'manage.py'): - debug.dbg('Found django path: %s', module_path) - result.append(parent) - return result - - -def _get_buildout_script_paths(module_path): - """ - if there is a 'buildout.cfg' file in one of the parent directories of the - given module it will return a list of all files in the buildout bin - directory that look like python files. - - :param module_path: absolute path to the module. - :type module_path: str - """ - project_root = _get_parent_dir_with_file(module_path, 'buildout.cfg') - if not project_root: - return [] - bin_path = os.path.join(project_root, 'bin') - if not os.path.exists(bin_path): - return [] - extra_module_paths = [] - for filename in os.listdir(bin_path): - try: - filepath = os.path.join(bin_path, filename) - with open(filepath, 'r') as f: - firstline = f.readline() - if firstline.startswith('#!') and 'python' in firstline: - extra_module_paths.append(filepath) - except (UnicodeDecodeError, IOError) as e: - # Probably a binary file; permission error or race cond. because file got deleted - # ignore - debug.warning(unicode(e)) - continue - return extra_module_paths - - -def dotted_path_in_sys_path(sys_path, module_path): - """ - Returns the dotted path inside a sys.path. - """ - # First remove the suffix. - for suffix, _, _ in imp.get_suffixes(): - if module_path.endswith(suffix): - module_path = module_path[:-len(suffix)] - break - else: - # There should always be a suffix in a valid Python file on the path. - return None - - if module_path.startswith(os.path.sep): - # The paths in sys.path most of the times don't end with a slash. - module_path = module_path[1:] - - for p in sys_path: - if module_path.startswith(p): - rest = module_path[len(p):] - if rest: - split = rest.split(os.path.sep) - for string in split: - if not string or '.' in string: - return None - return '.'.join(split) - - return None diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/usages.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/usages.py deleted file mode 100644 index 290c469..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/usages.py +++ /dev/null @@ -1,62 +0,0 @@ -from jedi.evaluate import imports -from jedi.evaluate.filters import TreeNameDefinition -from jedi.evaluate.context import ModuleContext - - -def _resolve_names(definition_names, avoid_names=()): - for name in definition_names: - if name in avoid_names: - # Avoiding recursions here, because goto on a module name lands - # on the same module. - continue - - if not isinstance(name, imports.SubModuleName): - # SubModuleNames are not actually existing names but created - # names when importing something like `import foo.bar.baz`. - yield name - - if name.api_type == 'module': - for name in _resolve_names(name.goto(), definition_names): - yield name - - -def _dictionarize(names): - return dict( - (n if n.tree_name is None else n.tree_name, n) - for n in names - ) - - -def _find_names(module_context, tree_name): - context = module_context.create_context(tree_name) - name = TreeNameDefinition(context, tree_name) - found_names = set(name.goto()) - found_names.add(name) - return _dictionarize(_resolve_names(found_names)) - - -def usages(module_context, tree_name): - search_name = tree_name.value - found_names = _find_names(module_context, tree_name) - modules = set(d.get_root_context() for d in found_names.values()) - modules = set(m for m in modules if isinstance(m, ModuleContext)) - - non_matching_usage_maps = {} - for m in imports.get_modules_containing_name(module_context.evaluator, modules, search_name): - for name_leaf in m.tree_node.get_used_names().get(search_name, []): - new = _find_names(m, name_leaf) - if any(tree_name in found_names for tree_name in new): - found_names.update(new) - for tree_name in new: - for dct in non_matching_usage_maps.get(tree_name, []): - # A usage that was previously searched for matches with - # a now found name. Merge. - found_names.update(dct) - try: - del non_matching_usage_maps[tree_name] - except KeyError: - pass - else: - for name in new: - non_matching_usage_maps.setdefault(name, []).append(new) - return found_names.values() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/utils.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/utils.py deleted file mode 100644 index 7fc1c24..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/evaluate/utils.py +++ /dev/null @@ -1,110 +0,0 @@ -""" A universal module with functions / classes without dependencies. """ -import sys -import contextlib -import functools - -from jedi._compatibility import reraise - - -def to_list(func): - def wrapper(*args, **kwargs): - return list(func(*args, **kwargs)) - return wrapper - - -def unite(iterable): - """Turns a two dimensional array into a one dimensional.""" - return set(typ for types in iterable for typ in types) - - -class UncaughtAttributeError(Exception): - """ - Important, because `__getattr__` and `hasattr` catch AttributeErrors - implicitly. This is really evil (mainly because of `__getattr__`). - `hasattr` in Python 2 is even more evil, because it catches ALL exceptions. - Therefore this class originally had to be derived from `BaseException` - instead of `Exception`. But because I removed relevant `hasattr` from - the code base, we can now switch back to `Exception`. - - :param base: return values of sys.exc_info(). - """ - - -def safe_property(func): - return property(reraise_uncaught(func)) - - -def reraise_uncaught(func): - """ - Re-throw uncaught `AttributeError`. - - Usage: Put ``@rethrow_uncaught`` in front of the function - which does **not** suppose to raise `AttributeError`. - - AttributeError is easily get caught by `hasattr` and another - ``except AttributeError`` clause. This becomes problem when you use - a lot of "dynamic" attributes (e.g., using ``@property``) because you - can't distinguish if the property does not exist for real or some code - inside of the "dynamic" attribute through that error. In a well - written code, such error should not exist but getting there is very - difficult. This decorator is to help us getting there by changing - `AttributeError` to `UncaughtAttributeError` to avoid unexpected catch. - This helps us noticing bugs earlier and facilitates debugging. - - .. note:: Treating StopIteration here is easy. - Add that feature when needed. - """ - @functools.wraps(func) - def wrapper(*args, **kwds): - try: - return func(*args, **kwds) - except AttributeError: - exc_info = sys.exc_info() - reraise(UncaughtAttributeError(exc_info[1]), exc_info[2]) - return wrapper - - -class PushBackIterator(object): - def __init__(self, iterator): - self.pushes = [] - self.iterator = iterator - self.current = None - - def push_back(self, value): - self.pushes.append(value) - - def __iter__(self): - return self - - def next(self): - """ Python 2 Compatibility """ - return self.__next__() - - def __next__(self): - if self.pushes: - self.current = self.pushes.pop() - else: - self.current = next(self.iterator) - return self.current - - -@contextlib.contextmanager -def ignored(*exceptions): - """ - Context manager that ignores all of the specified exceptions. This will - be in the standard library starting with Python 3.4. - """ - try: - yield - except exceptions: - pass - - -def indent_block(text, indention=' '): - """This function indents a text block with a default of four spaces.""" - temp = '' - while text and text[-1] == '\n': - temp += text[-1] - text = text[:-1] - lines = text.split('\n') - return '\n'.join(map(lambda s: indention + s, lines)) + temp diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/parser_utils.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/parser_utils.py deleted file mode 100644 index 59c6408..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/parser_utils.py +++ /dev/null @@ -1,241 +0,0 @@ -import textwrap -from inspect import cleandoc - -from jedi._compatibility import literal_eval, is_py3 -from parso.python import tree - -_EXECUTE_NODES = set([ - 'funcdef', 'classdef', 'import_from', 'import_name', 'test', 'or_test', - 'and_test', 'not_test', 'comparison', 'expr', 'xor_expr', 'and_expr', - 'shift_expr', 'arith_expr', 'atom_expr', 'term', 'factor', 'power', 'atom' -]) - -_FLOW_KEYWORDS = ( - 'try', 'except', 'finally', 'else', 'if', 'elif', 'with', 'for', 'while' -) - - -def get_executable_nodes(node, last_added=False): - """ - For static analysis. - """ - result = [] - typ = node.type - if typ == 'name': - next_leaf = node.get_next_leaf() - if last_added is False and node.parent.type != 'param' and next_leaf != '=': - result.append(node) - elif typ == 'expr_stmt': - # I think evaluating the statement (and possibly returned arrays), - # should be enough for static analysis. - result.append(node) - for child in node.children: - result += get_executable_nodes(child, last_added=True) - elif typ == 'decorator': - # decorator - if node.children[-2] == ')': - node = node.children[-3] - if node != '(': - result += get_executable_nodes(node) - else: - try: - children = node.children - except AttributeError: - pass - else: - if node.type in _EXECUTE_NODES and not last_added: - result.append(node) - - for child in children: - result += get_executable_nodes(child, last_added) - - return result - - -def get_comp_fors(comp_for): - yield comp_for - last = comp_for.children[-1] - while True: - if last.type == 'comp_for': - yield last - elif not last.type == 'comp_if': - break - last = last.children[-1] - - -def for_stmt_defines_one_name(for_stmt): - """ - Returns True if only one name is returned: ``for x in y``. - Returns False if the for loop is more complicated: ``for x, z in y``. - - :returns: bool - """ - return for_stmt.children[1].type == 'name' - - -def get_flow_branch_keyword(flow_node, node): - start_pos = node.start_pos - if not (flow_node.start_pos < start_pos <= flow_node.end_pos): - raise ValueError('The node is not part of the flow.') - - keyword = None - for i, child in enumerate(flow_node.children): - if start_pos < child.start_pos: - return keyword - first_leaf = child.get_first_leaf() - if first_leaf in _FLOW_KEYWORDS: - keyword = first_leaf - return 0 - -def get_statement_of_position(node, pos): - for c in node.children: - if c.start_pos <= pos <= c.end_pos: - if c.type not in ('decorated', 'simple_stmt', 'suite') \ - and not isinstance(c, (tree.Flow, tree.ClassOrFunc)): - return c - else: - try: - return get_statement_of_position(c, pos) - except AttributeError: - pass # Must be a non-scope - return None - - -def clean_scope_docstring(scope_node): - """ Returns a cleaned version of the docstring token. """ - node = scope_node.get_doc_node() - if node is not None: - # TODO We have to check next leaves until there are no new - # leaves anymore that might be part of the docstring. A - # docstring can also look like this: ``'foo' 'bar' - # Returns a literal cleaned version of the ``Token``. - cleaned = cleandoc(safe_literal_eval(node.value)) - # Since we want the docstr output to be always unicode, just - # force it. - if is_py3 or isinstance(cleaned, unicode): - return cleaned - else: - return unicode(cleaned, 'UTF-8', 'replace') - return '' - - -def safe_literal_eval(value): - first_two = value[:2].lower() - if first_two[0] == 'f' or first_two in ('fr', 'rf'): - # literal_eval is not able to resovle f literals. We have to do that - # manually, but that's right now not implemented. - return '' - - try: - return literal_eval(value) - except SyntaxError: - # It's possible to create syntax errors with literals like rb'' in - # Python 2. This should not be possible and in that case just return an - # empty string. - # Before Python 3.3 there was a more strict definition in which order - # you could define literals. - return '' - - -def get_call_signature(funcdef, width=72, call_string=None): - """ - Generate call signature of this function. - - :param width: Fold lines if a line is longer than this value. - :type width: int - :arg func_name: Override function name when given. - :type func_name: str - - :rtype: str - """ - # Lambdas have no name. - if call_string is None: - if funcdef.type == 'lambdef': - call_string = '' - else: - call_string = funcdef.name.value - if funcdef.type == 'lambdef': - p = '(' + ''.join(param.get_code() for param in funcdef.get_params()).strip() + ')' - else: - p = funcdef.children[2].get_code() - code = call_string + p - - return '\n'.join(textwrap.wrap(code, width)) - - -def get_doc_with_call_signature(scope_node): - """ - Return a document string including call signature. - """ - call_signature = None - if scope_node.type == 'classdef': - for funcdef in scope_node.iter_funcdefs(): - if funcdef.name.value == '__init__': - call_signature = \ - get_call_signature(funcdef, call_string=scope_node.name.value) - elif scope_node.type in ('funcdef', 'lambdef'): - call_signature = get_call_signature(scope_node) - - doc = clean_scope_docstring(scope_node) - if call_signature is None: - return doc - return '%s\n\n%s' % (call_signature, doc) - - -def move(node, line_offset): - """ - Move the `Node` start_pos. - """ - try: - children = node.children - except AttributeError: - node.line += line_offset - else: - for c in children: - move(c, line_offset) - - -def get_following_comment_same_line(node): - """ - returns (as string) any comment that appears on the same line, - after the node, including the # - """ - try: - if node.type == 'for_stmt': - whitespace = node.children[5].get_first_leaf().prefix - elif node.type == 'with_stmt': - whitespace = node.children[3].get_first_leaf().prefix - else: - whitespace = node.get_last_leaf().get_next_leaf().prefix - except AttributeError: - return None - except ValueError: - # TODO in some particular cases, the tree doesn't seem to be linked - # correctly - return None - if "#" not in whitespace: - return None - comment = whitespace[whitespace.index("#"):] - if "\r" in comment: - comment = comment[:comment.index("\r")] - if "\n" in comment: - comment = comment[:comment.index("\n")] - return comment - - -def is_scope(node): - return node.type in ('file_input', 'classdef', 'funcdef', 'lambdef', 'comp_for') - - -def get_parent_scope(node, include_flows=False): - """ - Returns the underlying scope. - """ - scope = node.parent - while scope is not None: - if include_flows and isinstance(scope, tree.Flow): - return scope - if is_scope(scope): - break - scope = scope.parent - return scope diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/refactoring.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/refactoring.py deleted file mode 100644 index ee93842..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/refactoring.py +++ /dev/null @@ -1,200 +0,0 @@ -""" -Introduce some basic refactoring functions to |jedi|. This module is still in a -very early development stage and needs much testing and improvement. - -.. warning:: I won't do too much here, but if anyone wants to step in, please - do. Refactoring is none of my priorities - -It uses the |jedi| `API `_ and supports currently the -following functions (sometimes bug-prone): - -- rename -- extract variable -- inline variable -""" -import difflib - -from parso import python_bytes_to_unicode, split_lines -from jedi.evaluate import helpers - - -class Refactoring(object): - def __init__(self, change_dct): - """ - :param change_dct: dict(old_path=(new_path, old_lines, new_lines)) - """ - self.change_dct = change_dct - - def old_files(self): - dct = {} - for old_path, (new_path, old_l, new_l) in self.change_dct.items(): - dct[old_path] = '\n'.join(old_l) - return dct - - def new_files(self): - dct = {} - for old_path, (new_path, old_l, new_l) in self.change_dct.items(): - dct[new_path] = '\n'.join(new_l) - return dct - - def diff(self): - texts = [] - for old_path, (new_path, old_l, new_l) in self.change_dct.items(): - if old_path: - udiff = difflib.unified_diff(old_l, new_l) - else: - udiff = difflib.unified_diff(old_l, new_l, old_path, new_path) - texts.append('\n'.join(udiff)) - return '\n'.join(texts) - - -def rename(script, new_name): - """ The `args` / `kwargs` params are the same as in `api.Script`. - :param operation: The refactoring operation to execute. - :type operation: str - :type source: str - :return: list of changed lines/changed files - """ - return Refactoring(_rename(script.usages(), new_name)) - - -def _rename(names, replace_str): - """ For both rename and inline. """ - order = sorted(names, key=lambda x: (x.module_path, x.line, x.column), - reverse=True) - - def process(path, old_lines, new_lines): - if new_lines is not None: # goto next file, save last - dct[path] = path, old_lines, new_lines - - dct = {} - current_path = object() - new_lines = old_lines = None - for name in order: - if name.in_builtin_module(): - continue - if current_path != name.module_path: - current_path = name.module_path - - process(current_path, old_lines, new_lines) - if current_path is not None: - # None means take the source that is a normal param. - with open(current_path) as f: - source = f.read() - - new_lines = split_lines(python_bytes_to_unicode(source)) - old_lines = new_lines[:] - - nr, indent = name.line, name.column - line = new_lines[nr - 1] - new_lines[nr - 1] = line[:indent] + replace_str + \ - line[indent + len(name.name):] - process(current_path, old_lines, new_lines) - return dct - - -def extract(script, new_name): - """ The `args` / `kwargs` params are the same as in `api.Script`. - :param operation: The refactoring operation to execute. - :type operation: str - :type source: str - :return: list of changed lines/changed files - """ - new_lines = split_lines(python_bytes_to_unicode(script.source)) - old_lines = new_lines[:] - - user_stmt = script._parser.user_stmt() - - # TODO care for multiline extracts - dct = {} - if user_stmt: - pos = script._pos - line_index = pos[0] - 1 - arr, index = helpers.array_for_pos(user_stmt, pos) - if arr is not None: - start_pos = arr[index].start_pos - end_pos = arr[index].end_pos - - # take full line if the start line is different from end line - e = end_pos[1] if end_pos[0] == start_pos[0] else None - start_line = new_lines[start_pos[0] - 1] - text = start_line[start_pos[1]:e] - for l in range(start_pos[0], end_pos[0] - 1): - text += '\n' + l - if e is None: - end_line = new_lines[end_pos[0] - 1] - text += '\n' + end_line[:end_pos[1]] - - # remove code from new lines - t = text.lstrip() - del_start = start_pos[1] + len(text) - len(t) - - text = t.rstrip() - del_end = len(t) - len(text) - if e is None: - new_lines[end_pos[0] - 1] = end_line[end_pos[1] - del_end:] - e = len(start_line) - else: - e = e - del_end - start_line = start_line[:del_start] + new_name + start_line[e:] - new_lines[start_pos[0] - 1] = start_line - new_lines[start_pos[0]:end_pos[0] - 1] = [] - - # add parentheses in multiline case - open_brackets = ['(', '[', '{'] - close_brackets = [')', ']', '}'] - if '\n' in text and not (text[0] in open_brackets and text[-1] == - close_brackets[open_brackets.index(text[0])]): - text = '(%s)' % text - - # add new line before statement - indent = user_stmt.start_pos[1] - new = "%s%s = %s" % (' ' * indent, new_name, text) - new_lines.insert(line_index, new) - dct[script.path] = script.path, old_lines, new_lines - return Refactoring(dct) - - -def inline(script): - """ - :type script: api.Script - """ - new_lines = split_lines(python_bytes_to_unicode(script.source)) - - dct = {} - - definitions = script.goto_assignments() - assert len(definitions) == 1 - stmt = definitions[0]._definition - usages = script.usages() - inlines = [r for r in usages - if not stmt.start_pos <= (r.line, r.column) <= stmt.end_pos] - inlines = sorted(inlines, key=lambda x: (x.module_path, x.line, x.column), - reverse=True) - expression_list = stmt.expression_list() - # don't allow multiline refactorings for now. - assert stmt.start_pos[0] == stmt.end_pos[0] - index = stmt.start_pos[0] - 1 - - line = new_lines[index] - replace_str = line[expression_list[0].start_pos[1]:stmt.end_pos[1] + 1] - replace_str = replace_str.strip() - # tuples need parentheses - if expression_list and isinstance(expression_list[0], pr.Array): - arr = expression_list[0] - if replace_str[0] not in ['(', '[', '{'] and len(arr) > 1: - replace_str = '(%s)' % replace_str - - # if it's the only assignment, remove the statement - if len(stmt.get_defined_names()) == 1: - line = line[:stmt.start_pos[1]] + line[stmt.end_pos[1]:] - - dct = _rename(inlines, replace_str) - # remove the empty line - new_lines = dct[script.path][2] - if line.strip(): - new_lines[index] = line - else: - new_lines.pop(index) - - return Refactoring(dct) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/settings.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/settings.py deleted file mode 100644 index f1ae6db..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/settings.py +++ /dev/null @@ -1,163 +0,0 @@ -""" -This module contains variables with global |jedi| settings. To change the -behavior of |jedi|, change the variables defined in :mod:`jedi.settings`. - -Plugins should expose an interface so that the user can adjust the -configuration. - - -Example usage:: - - from jedi import settings - settings.case_insensitive_completion = True - - -Completion output -~~~~~~~~~~~~~~~~~ - -.. autodata:: case_insensitive_completion -.. autodata:: add_bracket_after_function -.. autodata:: no_completion_duplicates - - -Filesystem cache -~~~~~~~~~~~~~~~~ - -.. autodata:: cache_directory -.. autodata:: use_filesystem_cache - - -Parser -~~~~~~ - -.. autodata:: fast_parser - - -Dynamic stuff -~~~~~~~~~~~~~ - -.. autodata:: dynamic_array_additions -.. autodata:: dynamic_params -.. autodata:: dynamic_params_for_other_modules -.. autodata:: additional_dynamic_modules -.. autodata:: auto_import_modules - - -Caching -~~~~~~~ - -.. autodata:: call_signatures_validity - - -""" -import os -import platform - -# ---------------- -# completion output settings -# ---------------- - -case_insensitive_completion = True -""" -The completion is by default case insensitive. -""" - -add_bracket_after_function = False -""" -Adds an opening bracket after a function, because that's normal behaviour. -Removed it again, because in VIM that is not very practical. -""" - -no_completion_duplicates = True -""" -If set, completions with the same name don't appear in the output anymore, -but are in the `same_name_completions` attribute. -""" - -# ---------------- -# Filesystem cache -# ---------------- - -use_filesystem_cache = True -""" -Use filesystem cache to save once parsed files with pickle. -""" - -if platform.system().lower() == 'windows': - _cache_directory = os.path.join(os.getenv('APPDATA') or '~', 'Jedi', - 'Jedi') -elif platform.system().lower() == 'darwin': - _cache_directory = os.path.join('~', 'Library', 'Caches', 'Jedi') -else: - _cache_directory = os.path.join(os.getenv('XDG_CACHE_HOME') or '~/.cache', - 'jedi') -cache_directory = os.path.expanduser(_cache_directory) -""" -The path where the cache is stored. - -On Linux, this defaults to ``~/.cache/jedi/``, on OS X to -``~/Library/Caches/Jedi/`` and on Windows to ``%APPDATA%\\Jedi\\Jedi\\``. -On Linux, if environment variable ``$XDG_CACHE_HOME`` is set, -``$XDG_CACHE_HOME/jedi`` is used instead of the default one. -""" - -# ---------------- -# parser -# ---------------- - -fast_parser = True -""" -Use the fast parser. This means that reparsing is only being done if -something has been changed e.g. to a function. If this happens, only the -function is being reparsed. -""" - -# ---------------- -# dynamic stuff -# ---------------- - -dynamic_array_additions = True -""" -check for `append`, etc. on arrays: [], {}, () as well as list/set calls. -""" - -dynamic_params = True -""" -A dynamic param completion, finds the callees of the function, which define -the params of a function. -""" - -dynamic_params_for_other_modules = True -""" -Do the same for other modules. -""" - -additional_dynamic_modules = [] -""" -Additional modules in which |jedi| checks if statements are to be found. This -is practical for IDEs, that want to administrate their modules themselves. -""" - -dynamic_flow_information = True -""" -Check for `isinstance` and other information to infer a type. -""" - -auto_import_modules = [ - 'hashlib', # setattr -] -""" -Modules that are not analyzed but imported, although they contain Python code. -This improves autocompletion for libraries that use ``setattr`` or -``globals()`` modifications a lot. -""" - -# ---------------- -# caching validity (time) -# ---------------- - -call_signatures_validity = 3.0 -""" -Finding function calls might be slow (0.1-0.5s). This is not acceptible for -normal writing. Therefore cache it for a short time. -""" diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/utils.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/utils.py deleted file mode 100644 index 177524c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/jedi/utils.py +++ /dev/null @@ -1,136 +0,0 @@ -""" -Utilities for end-users. -""" - -from __future__ import absolute_import -import __main__ -from collections import namedtuple -import logging -import traceback -import re -import os -import sys - -from parso import split_lines - -from jedi import Interpreter -from jedi.api.helpers import get_on_completion_name - - -READLINE_DEBUG = False - - -def setup_readline(namespace_module=__main__): - """ - Install Jedi completer to :mod:`readline`. - - This function setups :mod:`readline` to use Jedi in Python interactive - shell. If you want to use a custom ``PYTHONSTARTUP`` file (typically - ``$HOME/.pythonrc.py``), you can add this piece of code:: - - try: - from jedi.utils import setup_readline - setup_readline() - except ImportError: - # Fallback to the stdlib readline completer if it is installed. - # Taken from http://docs.python.org/2/library/rlcompleter.html - print("Jedi is not installed, falling back to readline") - try: - import readline - import rlcompleter - readline.parse_and_bind("tab: complete") - except ImportError: - print("Readline is not installed either. No tab completion is enabled.") - - This will fallback to the readline completer if Jedi is not installed. - The readline completer will only complete names in the global namespace, - so for example:: - - ran - - will complete to ``range`` - - with both Jedi and readline, but:: - - range(10).cou - - will show complete to ``range(10).count`` only with Jedi. - - You'll also need to add ``export PYTHONSTARTUP=$HOME/.pythonrc.py`` to - your shell profile (usually ``.bash_profile`` or ``.profile`` if you use - bash). - - """ - if READLINE_DEBUG: - logging.basicConfig( - filename='/tmp/jedi.log', - filemode='a', - level=logging.DEBUG - ) - - class JediRL(object): - def complete(self, text, state): - """ - This complete stuff is pretty weird, a generator would make - a lot more sense, but probably due to backwards compatibility - this is still the way how it works. - - The only important part is stuff in the ``state == 0`` flow, - everything else has been copied from the ``rlcompleter`` std. - library module. - """ - if state == 0: - sys.path.insert(0, os.getcwd()) - # Calling python doesn't have a path, so add to sys.path. - try: - logging.debug("Start REPL completion: " + repr(text)) - interpreter = Interpreter(text, [namespace_module.__dict__]) - - lines = split_lines(text) - position = (len(lines), len(lines[-1])) - name = get_on_completion_name( - interpreter._get_module_node(), - lines, - position - ) - before = text[:len(text) - len(name)] - completions = interpreter.completions() - except: - logging.error("REPL Completion error:\n" + traceback.format_exc()) - raise - finally: - sys.path.pop(0) - - self.matches = [before + c.name_with_symbols for c in completions] - try: - return self.matches[state] - except IndexError: - return None - - try: - import readline - except ImportError: - print("Jedi: Module readline not available.") - else: - readline.set_completer(JediRL().complete) - readline.parse_and_bind("tab: complete") - # jedi itself does the case matching - readline.parse_and_bind("set completion-ignore-case on") - # because it's easier to hit the tab just once - readline.parse_and_bind("set show-all-if-unmodified") - readline.parse_and_bind("set show-all-if-ambiguous on") - # don't repeat all the things written in the readline all the time - readline.parse_and_bind("set completion-prefix-display-length 2") - # No delimiters, Jedi handles that. - readline.set_completer_delims('') - - -def version_info(): - """ - Returns a namedtuple of Jedi's version, similar to Python's - ``sys.version_info``. - """ - Version = namedtuple('Version', 'major, minor, micro') - from jedi import __version__ - tupl = re.findall('[a-z]+|\d+', __version__) - return Version(*[x if i == 3 else int(x) for i, x in enumerate(tupl)]) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/__init__.py deleted file mode 100644 index 374dd94..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -""" needed for some modules to test against packages. """ - -some_variable = 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/arrays.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/arrays.py deleted file mode 100644 index 8be1cec..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/arrays.py +++ /dev/null @@ -1,436 +0,0 @@ -# ----------------- -# basic array lookups -# ----------------- - - -#? int() -[1,""][0] -#? str() -[1,""][1] -#? int() str() -[1,""][2] -#? int() str() -[1,""][20] -#? int() str() -[1,""][str(hello)] - -a = list() -#? list() -[a][0] - -#? list() -[[a,a,a]][2][100] - -c = [[a,""]] -#? str() -c[0][1] - -b = [6,7] - -#? int() -b[8-7] - -# ----------------- -# Slices -# ----------------- -#? list() -b[8:] - -#? list() -b[int():] - -#? list() -b[:] - - -class _StrangeSlice(): - def __getitem__(self, sliced): - return sliced - -# Should not result in an error, just because the slice itself is returned. -#? slice() -_StrangeSlice()[1:2] - - -# ----------------- -# iterable multiplication -# ----------------- -a = ['']*2 -#? list() -a - -# ----------------- -# tuple assignments -# ----------------- -a1, b1 = (1, "") -#? int() -a1 -#? str() -b1 - -(a2, b2) = (1, "") -#? int() -a2 -#? str() -b2 - -# list assignment -[list1, list2] = (1, "") -#? int() -list1 -#? str() -list2 - -[list3, list4] = [1, ""] -#? int() -list3 -#? str() -list4 - -# ----------------- -# subtuple assignment -# ----------------- -(a3, (b3, c3)) = (1, ("", list)) -#? list -c3 - -a4, (b4, c4) = (1, ("", list)) -#? list -c4 -#? int() -a4 -#? str() -b4 - - -# ----------------- -# multiple assignments -# ----------------- -a = b = 1 -#? int() -a -#? int() -b - -(a, b) = (c, (e, f)) = ('2', (3, 4)) -#? str() -a -#? tuple() -b -#? str() -c -#? int() -e -#? int() -f - - -# ----------------- -# unnessecary braces -# ----------------- -a = (1) -#? int() -a -#? int() -(1) -#? int() -((1)) -#? int() -((1)+1) - -u, v = 1, "" -#? int() -u - -((u1, v1)) = 1, "" -#? int() -u1 -#? int() -(u1) - -(a), b = 1, '' -#? int() -a - -def a(): return '' -#? str() -(a)() -#? str() -(a)().replace() -#? int() -(tuple).index() -#? int() -(tuple)().index() - -class C(): - def __init__(self): - self.a = (str()).upper() - -#? str() -C().a - -# ----------------- -# imbalanced sides -# ----------------- -(f, g) = (1,) -#? int() -f -#? [] -g. - -(f, g, h) = (1,'') -#? int() -f -#? str() -g -#? [] -h. - -(f1, g1) = 1 -#? [] -f1. -#? [] -g1. - -(f, g) = (1,'',1.0) -#? int() -f -#? str() -g - -# ----------------- -# dicts -# ----------------- -dic2 = {'asdf': 3, 'b': 'str'} -#? int() -dic2['asdf'] - -# string literal -#? int() -dic2[r'asdf'] -#? int() -dic2[r'asdf'] -#? int() -dic2[r'as' 'd' u'f'] -#? int() str() -dic2['just_something'] - -# unpacking -a, b = dic2 -#? str() -a -a, b = {1: 'x', 2.0: 1j} -#? int() float() -a -#? int() float() -b - - -def f(): - """ github #83 """ - r = {} - r['status'] = (200, 'ok') - return r - -#? dict() -f() - -# completion within dicts -#? 9 ['str'] -{str: str} - -# iteration problem (detected with sith) -d = dict({'a':''}) -def y(a): - return a -#? -y(**d) - -# problem with more complicated casts -dic = {str(key): ''} -#? str() -dic[''] - - -for x in {1: 3.0, '': 1j}: - #? int() str() - x - -# ----------------- -# with variable as index -# ----------------- -a = (1, "") -index = 1 -#? str() -a[index] - -# these should just ouput the whole array -index = int -#? int() str() -a[index] -index = int() -#? int() str() -a[index] - -# dicts -index = 'asdf' - -dic2 = {'asdf': 3, 'b': 'str'} -#? int() -dic2[index] - -# ----------------- -# __getitem__ -# ----------------- - -class GetItem(): - def __getitem__(self, index): - return 1.0 - -#? float() -GetItem()[0] - -class GetItem(): - def __init__(self, el): - self.el = el - - def __getitem__(self, index): - return self.el - -#? str() -GetItem("")[1] - -class GetItemWithList(): - def __getitem__(self, index): - return [1, 1.0, 's'][index] - -#? float() -GetItemWithList()[1] - -for i in 0, 2: - #? int() str() - GetItemWithList()[i] - - -# With super -class SuperYeah(list): - def __getitem__(self, index): - return super()[index] - -#? -SuperYeah([1])[0] -#? -SuperYeah()[0] - -# ----------------- -# conversions -# ----------------- - -a = [1, ""] -#? int() str() -list(a)[1] - -#? int() str() -list(a)[0] -#? -set(a)[0] - -#? int() str() -list(set(a))[1] -#? int() str() -next(iter(set(a))) -#? int() str() -list(list(set(a)))[1] - -# does not yet work, because the recursion catching is not good enough (catches # to much) -#? int() str() -list(set(list(set(a))))[1] -#? int() str() -list(set(set(a)))[1] - -# frozenset -#? int() str() -list(frozenset(a))[1] -#? int() str() -list(set(frozenset(a)))[1] - -# iter -#? int() str() -list(iter(a))[1] -#? int() str() -list(iter(list(set(a))))[1] - -# tuple -#? int() str() -tuple(a)[1] -#? int() str() -tuple(list(set(a)))[1] - -#? int() -tuple((1,))[0] - -# implementation detail for lists, should not be visible -#? [] -list().__iterable - -# With a list comprehension. -for i in set(a for a in [1]): - #? int() - i - - -# ----------------- -# Merged Arrays -# ----------------- - -for x in [1] + ['']: - #? int() str() - x - -# ----------------- -# For loops with attribute assignment. -# ----------------- -def test_func(): - x = 'asdf' - for x.something in [6,7,8]: - pass - #? str() - x - - for x.something, b in [[6, 6.0]]: - pass - #? str() - x - - -# python >= 2.7 -# Set literals are not valid in 2.6. -#? int() -tuple({1})[0] - -# python >= 3.3 -# ----------------- -# PEP 3132 Extended Iterable Unpacking (star unpacking) -# ----------------- - -a, *b, c = [1, 'b', list, dict] -#? int() -a -#? str() -b -#? list -c - -# Not valid syntax -a, *b, *c = [1, 'd', list] -#? int() -a -#? str() -b -#? list -c - -lc = [x for a, *x in [(1, '', 1.0)]] - -#? -lc[0][0] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/async_.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/async_.py deleted file mode 100644 index b220213..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/async_.py +++ /dev/null @@ -1,36 +0,0 @@ -""" -Tests for all async use cases. - -Currently we're not supporting completion of them, but they should at least not -raise errors or return extremely strange results. -""" - -async def x(): - argh = await x() - #? - argh - return 2 - -#? int() -x() - -a = await x() -#? -a - - -async def x2(): - async with open('asdf') as f: - #? ['readlines'] - f.readlines - -class A(): - @staticmethod - async def b(c=1, d=2): - return 1 - -#! 9 ['def b'] -await A.b() - -#! 11 ['param d=2'] -await A.b(d=3) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/basic.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/basic.py deleted file mode 100644 index 34e8810..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/basic.py +++ /dev/null @@ -1,295 +0,0 @@ -# ----------------- -# cursor position -# ----------------- -#? 0 int -int() -#? 3 int -int() -#? 4 str -int(str) - - -# ----------------- -# should not complete -# ----------------- -#? [] -. -#? [] -str.. -#? [] -a(0):. - -# ----------------- -# if/else/elif -# ----------------- - -if (random.choice([0, 1])): - 1 -elif(random.choice([0, 1])): - a = 3 -else: - a = '' -#? int() str() -a -def func(): - if random.choice([0, 1]): - 1 - elif(random.choice([0, 1])): - a = 3 - else: - a = '' - #? int() str() - return a -#? int() str() -func() - -# ----------------- -# keywords -# ----------------- - -#? list() -assert [] - -def focus_return(): - #? list() - return [] - - -# ----------------- -# for loops -# ----------------- - -for a in [1,2]: - #? int() - a - -for a1 in 1,"": - #? int() str() - a1 - -for a3, b3 in (1,""), (1,""), (1,""): - #? int() - a3 - #? str() - b3 - -for a4, (b4, c4) in (1,("", list)), (1,("", list)): - #? int() - a4 - #? str() - b4 - #? list - c4 - -a = [] -for i in [1,'']: - #? int() str() - i - a += [i] - -#? int() str() -a[0] - -for i in list([1,'']): - #? int() str() - i - -#? int() str() -for x in [1,'']: x - -a = [] -b = [1.0,''] -for i in b: - a += [i] - -#? float() str() -a[0] - -for i in [1,2,3]: - #? int() - i -else: - i - - -# ----------------- -# range() -# ----------------- -for i in range(10): - #? int() - i - -# ----------------- -# ternary operator -# ----------------- - -a = 3 -b = '' if a else set() -#? str() set() -b - -def ret(a): - return ['' if a else set()] - -#? str() set() -ret(1)[0] -#? str() set() -ret()[0] - -# ----------------- -# global vars -# ----------------- - -def global_define(): - global global_var_in_func - global_var_in_func = 3 - -#? int() -global_var_in_func - - -def funct1(): - # From issue #610 - global global_dict_var - global_dict_var = dict() -def funct2(): - global global_dict_var - #? dict() - global_dict_var - - -# ----------------- -# within docstrs -# ----------------- - -def a(): - """ - #? ['global_define'] - global_define - """ - pass - -#? -# str literals in comment """ upper - -def completion_in_comment(): - #? ['Exception'] - # might fail because the comment is not a leaf: Exception - pass - -some_word -#? ['Exception'] -# Very simple comment completion: Exception -# Commment after it - -# ----------------- -# magic methods -# ----------------- - -class A(object): pass -class B(): pass - -#? ['__init__'] -A.__init__ -#? ['__init__'] -B.__init__ - -#? ['__init__'] -int().__init__ - -# ----------------- -# comments -# ----------------- - -class A(): - def __init__(self): - self.hello = {} # comment shouldn't be a string -#? dict() -A().hello - -# ----------------- -# unicode -# ----------------- -a = 'smörbröd' -#? str() -a -xyz = 'smörbröd.py' -if 1: - #? str() - xyz - -#? -¹. - -# ----------------- -# exceptions -# ----------------- -try: - import math -except ImportError as i_a: - #? ['i_a'] - i_a - #? ImportError() - i_a -try: - import math -except ImportError, i_b: - # TODO check this only in Python2 - ##? ['i_b'] - i_b - ##? ImportError() - i_b - - -class MyException(Exception): - def __init__(self, my_attr): - self.my_attr = my_attr - -try: - raise MyException(1) -except MyException as e: - #? ['my_attr'] - e.my_attr - #? 22 ['my_attr'] - for x in e.my_attr: - pass - - -# ----------------- -# continuations -# ----------------- - -foo = \ -1 -#? int() -foo - -# ----------------- -# module attributes -# ----------------- - -# Don't move this to imports.py, because there's a star import. -#? str() -__file__ -#? ['__file__'] -__file__ - - -# ----------------- -# with statements -# ----------------- - -with open('') as f: - #? ['closed'] - f.closed - for line in f: - #? str() - line - -# Nested with statements don't exist in Python 2.6. -# python >= 2.7 -with open('') as f1, open('') as f2: - #? ['closed'] - f1.closed - #? ['closed'] - f2.closed diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/classes.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/classes.py deleted file mode 100644 index 292cfc3..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/classes.py +++ /dev/null @@ -1,535 +0,0 @@ -def find_class(): - """ This scope is special, because its in front of TestClass """ - #? ['ret'] - TestClass.ret - if 1: - #? ['ret'] - TestClass.ret - -class FindClass(): - #? [] - TestClass.ret - if a: - #? [] - TestClass.ret - - def find_class(self): - #? ['ret'] - TestClass.ret - if 1: - #? ['ret'] - TestClass.ret - -#? [] -FindClass().find_class.self -#? [] -FindClass().find_class.self.find_class - -# set variables, which should not be included, because they don't belong to the -# class -second = 1 -second = "" -class TestClass(object): - var_class = TestClass(1) - - def __init__(self2, first_param, second_param, third=1.0): - self2.var_inst = first_param - self2.second = second_param - self2.first = first_param - a = 3 - - def var_func(self): - return 1 - - def get_first(self): - # traversal - self.second_new = self.second - return self.var_inst - - def values(self): - self.var_local = 3 - #? ['var_class', 'var_func', 'var_inst', 'var_local'] - self.var_ - #? - var_local - - def ret(self, a1): - # should not know any class functions! - #? [] - values - #? ['return'] - ret - return a1 - -# should not work -#? [] -var_local -#? [] -var_inst -#? [] -var_func - -# instance -inst = TestClass(1) - -#? ['var_class', 'var_func', 'var_inst', 'var_local'] -inst.var - -#? ['var_class', 'var_func'] -TestClass.var - -#? int() -inst.var_local -#? [] -TestClass.var_local. - -#? int() -TestClass().ret(1) -# Should not return int(), because we want the type before `.ret(1)`. -#? 11 TestClass() -TestClass().ret(1) -#? int() -inst.ret(1) - -myclass = TestClass(1, '', 3.0) -#? int() -myclass.get_first() -#? [] -myclass.get_first.real - -# too many params -#? int() -TestClass(1,1,1).var_inst - -# too few params -#? int() -TestClass(1).first -#? [] -TestClass(1).second. - -# complicated variable settings in class -#? str() -myclass.second -#? str() -myclass.second_new - -# multiple classes / ordering -ints = TestClass(1, 1.0) -strs = TestClass("", '') -#? float() -ints.second -#? str() -strs.second - -#? ['var_class'] -TestClass.var_class.var_class.var_class.var_class - -# operations (+, *, etc) shouldn't be InstanceElements - #246 -class A(): - def __init__(self): - self.addition = 1 + 2 -#? int() -A().addition - -# should also work before `=` -#? 8 int() -A().addition = None -#? 8 int() -A(1).addition = None -#? 1 A -A(1).addition = None -a = A() -#? 8 int() -a.addition = None - - -# ----------------- -# inheritance -# ----------------- - -class Base(object): - def method_base(self): - return 1 - -class SuperClass(Base): - class_super = 3 - def __init__(self): - self.var_super = '' - def method_super(self): - self.var2_super = list - -class Mixin(SuperClass): - def method_mixin(self): - return int - -#? 20 SuperClass -class SubClass(SuperClass): - class_sub = 3 - def __init__(self): - self.var_sub = '' - def method_sub(self): - self.var_sub = list - return tuple - -instance = SubClass() - -#? ['method_base', 'method_sub', 'method_super'] -instance.method_ -#? ['var2_super', 'var_sub', 'var_super'] -instance.var -#? ['class_sub', 'class_super'] -instance.class_ - -#? ['method_base', 'method_sub', 'method_super'] -SubClass.method_ -#? [] -SubClass.var -#? ['class_sub', 'class_super'] -SubClass.class_ - -# ----------------- -# inheritance of builtins -# ----------------- - -class Base(str): - pass - -#? ['upper'] -Base.upper -#? ['upper'] -Base().upper - -# ----------------- -# dynamic inheritance -# ----------------- - -class Angry(object): - def shout(self): - return 'THIS IS MALARKEY!' - -def classgetter(): - return Angry - -class Dude(classgetter()): - def react(self): - #? ['shout'] - self.s - -# ----------------- -# __call__ -# ----------------- - -class CallClass(): - def __call__(self): - return 1 - -#? int() -CallClass()() - -# ----------------- -# variable assignments -# ----------------- - -class V: - def __init__(self, a): - self.a = a - - def ret(self): - return self.a - - d = b - b = ret - if 1: - c = b - -#? int() -V(1).b() -#? int() -V(1).c() -#? -V(1).d() -# Only keywords should be possible to complete. -#? ['is', 'in', 'not', 'and', 'or', 'if'] -V(1).d() - - -# ----------------- -# ordering -# ----------------- -class A(): - def b(self): - #? int() - a_func() - #? str() - self.a_func() - return a_func() - - def a_func(self): - return "" - -def a_func(): - return 1 - -#? int() -A().b() -#? str() -A().a_func() - -# ----------------- -# nested classes -# ----------------- -class A(): - class B(): - pass - def b(self): - return 1.0 - -#? float() -A().b() - -class A(): - def b(self): - class B(): - def b(self): - return [] - return B().b() - -#? list() -A().b() - -# ----------------- -# ducktyping -# ----------------- - -def meth(self): - return self.a, self.b - -class WithoutMethod(): - a = 1 - def __init__(self): - self.b = 1.0 - def blub(self): - return self.b - m = meth - -class B(): - b = '' - -a = WithoutMethod().m() -#? int() -a[0] -#? float() -a[1] - -#? float() -WithoutMethod.blub(WithoutMethod()) -#? str() -WithoutMethod.blub(B()) - -# ----------------- -# __getattr__ / getattr() / __getattribute__ -# ----------------- - -#? str().upper -getattr(str(), 'upper') -#? str.upper -getattr(str, 'upper') - -# some strange getattr calls -#? -getattr(str, 1) -#? -getattr() -#? -getattr(str) -#? -getattr(getattr, 1) -#? -getattr(str, []) - - -class Base(): - def ret(self, b): - return b - -class Wrapper(): - def __init__(self, obj): - self.obj = obj - - def __getattr__(self, name): - return getattr(self.obj, name) - -class Wrapper2(): - def __getattribute__(self, name): - return getattr(Base(), name) - -#? int() -Wrapper(Base()).ret(3) - -#? int() -Wrapper2(Base()).ret(3) - -class GetattrArray(): - def __getattr__(self, name): - return [1] - -#? int() -GetattrArray().something[0] - - -# ----------------- -# private vars -# ----------------- -class PrivateVar(): - def __init__(self): - self.__var = 1 - #? int() - self.__var - #? ['__var'] - self.__var - - def __private_func(self): - return 1 - - def wrap_private(self): - return self.__private_func() -#? [] -PrivateVar().__var -#? -PrivateVar().__var -#? [] -PrivateVar().__private_func -#? int() -PrivateVar().wrap_private() - - -class PrivateSub(PrivateVar): - def test(self): - #? [] - self.__var - - def wrap_private(self): - #? [] - self.__var - -#? [] -PrivateSub().__var - -# ----------------- -# super -# ----------------- -class Super(object): - a = 3 - def return_sup(self): - return 1 - -class TestSuper(Super): - #? - super() - def test(self): - #? Super() - super() - #? ['a'] - super().a - if 1: - #? Super() - super() - def a(): - #? - super() - - def return_sup(self): - #? int() - return super().return_sup() - -#? int() -TestSuper().return_sup() - - -# ----------------- -# if flow at class level -# ----------------- -class TestX(object): - def normal_method(self): - return 1 - - if True: - def conditional_method(self): - var = self.normal_method() - #? int() - var - return 2 - - def other_method(self): - var = self.conditional_method() - #? int() - var - -# ----------------- -# mro method -# ----------------- - -class A(object): - a = 3 - -#? ['mro'] -A.mro -#? [] -A().mro - - -# ----------------- -# mro resolution -# ----------------- - -class B(A()): - b = 3 - -#? -B.a -#? -B().a -#? int() -B.b -#? int() -B().b - - -# ----------------- -# With import -# ----------------- - -from import_tree.classes import Config2, BaseClass - -class Config(BaseClass): - """#884""" - -#? Config2() -Config.mode - -#? int() -Config.mode2 - - -# ----------------- -# Nested class/def/class -# ----------------- -class Foo(object): - a = 3 - def create_class(self): - class X(): - a = self.a - self.b = 3.0 - return X - -#? int() -Foo().create_class().a -#? float() -Foo().b - -class Foo(object): - def comprehension_definition(self): - return [1 for self.b in [1]] - -#? int() -Foo().b diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/completion.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/completion.py deleted file mode 100644 index 6700fa6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/completion.py +++ /dev/null @@ -1,50 +0,0 @@ -""" -Special cases of completions (typically special positions that caused issues -with context parsing. -""" - -def pass_decorator(func): - return func - - -def x(): - return ( - 1, -#? ["tuple"] -tuple - ) - - # Comment just somewhere - - -class MyClass: - @pass_decorator - def x(foo, -#? 5 ["tuple"] -tuple, - ): - return 1 - - -if x: - pass -#? ['else'] -else - -try: - pass -#? ['except', 'Exception'] -except - -try: - pass -#? 6 ['except', 'Exception'] -except AttributeError: - pass -#? ['finally'] -finally - -for x in y: - pass -#? ['else'] -else diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/complex.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/complex.py deleted file mode 100644 index 3ea8327..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/complex.py +++ /dev/null @@ -1,14 +0,0 @@ -""" Mostly for stupid error reports of @dbrgn. :-) """ - -import time - -class Foo(object): - global time - asdf = time - -def asdfy(): - return Foo - -xorz = getattr(asdfy()(), 'asdf') -#? time -xorz diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/comprehensions.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/comprehensions.py deleted file mode 100644 index 2894cf3..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/comprehensions.py +++ /dev/null @@ -1,215 +0,0 @@ -# ----------------- -# list comprehensions -# ----------------- - -# basics: - -a = ['' for a in [1]] -#? str() -a[0] -#? ['insert'] -a.insert - -a = [a for a in [1]] -#? int() -a[0] - -y = 1.0 -# Should not leak. -[y for y in [3]] -#? float() -y - -a = [a for a in (1, 2)] -#? int() -a[0] - -a = [a for a,b in [(1,'')]] -#? int() -a[0] - -arr = [1,''] -a = [a for a in arr] -#? int() -a[0] -#? str() -a[1] -#? int() str() -a[2] - -a = [a if 1.0 else '' for a in [1] if [1.0]] -#? int() str() -a[0] - -# name resolve should be correct -left, right = 'a', 'b' -left, right = [x for x in (left, right)] -#? str() -left - -# with a dict literal -#? int() -[a for a in {1:'x'}][0] - -# list comprehensions should also work in combination with functions -def listen(arg): - for x in arg: - #? str() - x - -listen(['' for x in [1]]) -#? -([str for x in []])[0] - -# ----------------- -# nested list comprehensions -# ----------------- - -b = [a for arr in [[1, 1.0]] for a in arr] -#? int() -b[0] -#? float() -b[1] - -b = [arr for arr in [[1, 1.0]] for a in arr] -#? int() -b[0][0] -#? float() -b[1][1] - -b = [a for arr in [[1]] if '' for a in arr if ''] -#? int() -b[0] - -b = [b for arr in [[[1.0]]] for a in arr for b in a] -#? float() -b[0] - -#? str() -[x for x in 'chr'][0] - -# jedi issue #26 -#? list() -a = [[int(v) for v in line.strip().split() if v] for line in ["123", str(), "123"] if line] -#? list() -a[0] -#? int() -a[0][0] - -# ----------------- -# generator comprehensions -# ----------------- - -left, right = (i for i in (1, '')) - -#? int() -left -#? str() -right - -gen = (i for i in (1,)) - -#? int() -next(gen) -#? -gen[0] - -gen = (a for arr in [[1.0]] for a in arr) -#? float() -next(gen) - -#? int() -(i for i in (1,)).send() - -# issues with different formats -left, right = (i for i in - ('1', 2)) -#? str() -left -#? int() -right - -# ----------------- -# name resolution in comprehensions. -# ----------------- - -def x(): - """Should not try to resolve to the if hio, which was a bug.""" - #? 22 - [a for a in h if hio] - if hio: pass - -# ----------------- -# slices -# ----------------- - -#? list() -foo = [x for x in [1, '']][:1] -#? int() -foo[0] -#? str() -foo[1] - -# ----------------- -# In class -# ----------------- - -class X(): - def __init__(self, bar): - self.bar = bar - - def foo(self): - x = [a for a in self.bar][0] - #? int() - x - return x - -#? int() -X([1]).foo() - -# set/dict comprehensions were introduced in 2.7, therefore: -# python >= 2.7 -# ----------------- -# dict comprehensions -# ----------------- - -#? int() -list({a - 1: 3 for a in [1]})[0] - -d = {a - 1: b for a, b in {1: 'a', 3: 1.0}.items()} -#? int() -list(d)[0] -#? str() float() -d.values()[0] -#? str() -d[0] -#? float() str() -d[1] -#? float() -d[2] - -# ----------------- -# set comprehensions -# ----------------- - -#? set() -{a - 1 for a in [1]} - -#? set() -{a for a in range(10)} - -#? int() -[x for x in {a for a in range(10)}][0] - -#? int() -{a for a in range(10)}.pop() -#? float() str() -{b for a in [[3.0], ['']] for b in a}.pop() - -#? int() -next(iter({a for a in range(10)})) - - -# with a set literal (also doesn't work in 2.6). -#? int() -[a for a in {1, 2, 3}][0] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/context.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/context.py deleted file mode 100644 index d3e79b8..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/context.py +++ /dev/null @@ -1,45 +0,0 @@ -class Base(): - myfoobar = 3 - - -class X(Base): - def func(self, foo): - pass - - -class Y(X): - def actual_function(self): - pass - - #? [] - def actual_function - #? ['func'] - def f - - #? [] - def __class__ - - #? ['__repr__'] - def __repr__ - - #? [] - def mro - - #? ['myfoobar'] - myfoobar - -#? [] -myfoobar - -# ----------------- -# Inheritance -# ----------------- - -class Super(): - enabled = True - if enabled: - yo_dude = 4 - -class Sub(Super): - #? ['yo_dude'] - yo_dud diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/decorators.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/decorators.py deleted file mode 100644 index 27e455a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/decorators.py +++ /dev/null @@ -1,318 +0,0 @@ -# ----------------- -# normal decorators -# ----------------- - -def decorator(func): - def wrapper(*args): - return func(1, *args) - return wrapper - -@decorator -def decorated(a,b): - return a,b - -exe = decorated(set, '') - -#? set -exe[1] - -#? int() -exe[0] - -# more complicated with args/kwargs -def dec(func): - def wrapper(*args, **kwargs): - return func(*args, **kwargs) - return wrapper - -@dec -def fu(a, b, c, *args, **kwargs): - return a, b, c, args, kwargs - -exe = fu(list, c=set, b=3, d='') - -#? list -exe[0] -#? int() -exe[1] -#? set -exe[2] -#? [] -exe[3][0]. -#? str() -exe[4]['d'] - - -exe = fu(list, set, 3, '', d='') - -#? str() -exe[3][0] - -# ----------------- -# multiple decorators -# ----------------- -def dec2(func2): - def wrapper2(first_arg, *args2, **kwargs2): - return func2(first_arg, *args2, **kwargs2) - return wrapper2 - -@dec2 -@dec -def fu2(a, b, c, *args, **kwargs): - return a, b, c, args, kwargs - -exe = fu2(list, c=set, b=3, d='str') - -#? list -exe[0] -#? int() -exe[1] -#? set -exe[2] -#? [] -exe[3][0]. -#? str() -exe[4]['d'] - - -# ----------------- -# Decorator is a class -# ----------------- -def same_func(func): - return func - -class Decorator(object): - def __init__(self, func): - self.func = func - - def __call__(self, *args, **kwargs): - return self.func(1, *args, **kwargs) - -@Decorator -def nothing(a,b,c): - return a,b,c - -#? int() -nothing("")[0] -#? str() -nothing("")[1] - - -@same_func -@Decorator -def nothing(a,b,c): - return a,b,c - -#? int() -nothing("")[0] - -class MethodDecoratorAsClass(): - class_var = 3 - @Decorator - def func_without_self(arg, arg2): - return arg, arg2 - - @Decorator - def func_with_self(self, arg): - return self.class_var - -#? int() -MethodDecoratorAsClass().func_without_self('')[0] -#? str() -MethodDecoratorAsClass().func_without_self('')[1] -#? -MethodDecoratorAsClass().func_with_self(1) - - -class SelfVars(): - """Init decorator problem as an instance, #247""" - @Decorator - def __init__(self): - """ - __init__ decorators should be ignored when looking up variables in the - class. - """ - self.c = list - - @Decorator - def shouldnt_expose_var(not_self): - """ - Even though in real Python this shouldn't expose the variable, in this - case Jedi exposes the variable, because these kind of decorators are - normally descriptors, which SHOULD be exposed (at least 90%). - """ - not_self.b = 1.0 - - def other_method(self): - #? float() - self.b - #? list - self.c - -# ----------------- -# not found decorators (are just ignored) -# ----------------- -@not_found_decorator -def just_a_func(): - return 1 - -#? int() -just_a_func() - -#? ['__closure__'] -just_a_func.__closure__ - - -class JustAClass: - @not_found_decorator2 - def a(self): - return 1 - -#? ['__call__'] -JustAClass().a.__call__ -#? int() -JustAClass().a() -#? ['__call__'] -JustAClass.a.__call__ -#? int() -JustAClass.a() - -# ----------------- -# illegal decorators -# ----------------- - -class DecoratorWithoutCall(): - def __init__(self, func): - self.func = func - -@DecoratorWithoutCall -def f(): - return 1 - -# cannot be resolved - should be ignored -@DecoratorWithoutCall(None) -def g(): - return 1 - -#? -f() -#? int() -g() - - -class X(): - @str - def x(self): - pass - - def y(self): - #? str() - self.x - #? - self.x() - -# ----------------- -# method decorators -# ----------------- - -def dec(f): - def wrapper(s): - return f(s) - return wrapper - -class MethodDecorators(): - _class_var = 1 - def __init__(self): - self._method_var = '' - - @dec - def constant(self): - return 1.0 - - @dec - def class_var(self): - return self._class_var - - @dec - def method_var(self): - return self._method_var - -#? float() -MethodDecorators().constant() -#? int() -MethodDecorators().class_var() -#? str() -MethodDecorators().method_var() - - -class Base(): - @not_existing - def __init__(self): - pass - @not_existing - def b(self): - return '' - @dec - def c(self): - return 1 - -class MethodDecoratorDoesntExist(Base): - """#272 github: combination of method decorators and super()""" - def a(self): - #? - super().__init__() - #? str() - super().b() - #? int() - super().c() - #? float() - self.d() - - @doesnt_exist - def d(self): - return 1.0 - -# ----------------- -# others -# ----------------- -def memoize(function): - def wrapper(*args): - if random.choice([0, 1]): - pass - else: - rv = function(*args) - return rv - return wrapper - -@memoize -def follow_statement(stmt): - return stmt - -# here we had problems with the else clause, because the parent was not right. -#? int() -follow_statement(1) - -# ----------------- -# class decorators -# ----------------- - -# class decorators should just be ignored -@should_ignore -class A(): - def ret(self): - return 1 - -#? int() -A().ret() - - -# ----------------- -# On decorator completions -# ----------------- - -import abc -#? ['abc'] -@abc - -#? ['abstractmethod'] -@abc.abstractmethod diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/definition.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/definition.py deleted file mode 100644 index f896984..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/definition.py +++ /dev/null @@ -1,68 +0,0 @@ -""" -Fallback to callee definition when definition not found. -- https://github.com/davidhalter/jedi/issues/131 -- https://github.com/davidhalter/jedi/pull/149 -""" - -"""Parenthesis closed at next line.""" - -# Ignore these definitions for a little while, not sure if we really want them. -# python <= 2.5 - -#? isinstance -isinstance( -) - -#? isinstance -isinstance( -) - -#? isinstance -isinstance(None, -) - -#? isinstance -isinstance(None, -) - -"""Parenthesis closed at same line.""" - -# Note: len('isinstance(') == 11 -#? 11 isinstance -isinstance() - -# Note: len('isinstance(None,') == 16 -##? 16 isinstance -isinstance(None,) - -# Note: len('isinstance(None,') == 16 -##? 16 isinstance -isinstance(None, ) - -# Note: len('isinstance(None, ') == 17 -##? 17 isinstance -isinstance(None, ) - -# Note: len('isinstance( ') == 12 -##? 12 isinstance -isinstance( ) - -"""Unclosed parenthesis.""" - -#? isinstance -isinstance( - -def x(): pass # acts like EOF - -##? isinstance -isinstance( - -def x(): pass # acts like EOF - -#? isinstance -isinstance(None, - -def x(): pass # acts like EOF - -##? isinstance -isinstance(None, diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/descriptors.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/descriptors.py deleted file mode 100644 index 3cc01fa..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/descriptors.py +++ /dev/null @@ -1,221 +0,0 @@ -class RevealAccess(object): - """ - A data descriptor that sets and returns values - normally and prints a message logging their access. - """ - def __init__(self, initval=None, name='var'): - self.val = initval - self.name = name - - def __get__(self, obj, objtype): - print('Retrieving', self.name) - return self.val - - def __set__(self, obj, val): - print('Updating', self.name) - self.val = val - - def just_a_method(self): - pass - -class C(object): - x = RevealAccess(10, 'var "x"') - #? RevealAccess() - x - #? ['just_a_method'] - x.just_a_method - y = 5.0 - def __init__(self): - #? int() - self.x - - #? [] - self.just_a_method - #? [] - C.just_a_method - -m = C() -#? int() -m.x -#? float() -m.y -#? int() -C.x - -#? [] -m.just_a_method -#? [] -C.just_a_method - -# ----------------- -# properties -# ----------------- -class B(): - @property - def r(self): - return 1 - @r.setter - def r(self, value): - return '' - def t(self): - return '' - p = property(t) - -#? [] -B().r(). -#? int() -B().r - -#? str() -B().p -#? [] -B().p(). - -class PropClass(): - def __init__(self, a): - self.a = a - @property - def ret(self): - return self.a - - @ret.setter - def ret(self, value): - return 1.0 - - def ret2(self): - return self.a - ret2 = property(ret2) - - @property - def nested(self): - """ causes recusions in properties, should work """ - return self.ret - - @property - def nested2(self): - """ causes recusions in properties, should not work """ - return self.nested2 - - @property - def join1(self): - """ mutual recusion """ - return self.join2 - - @property - def join2(self): - """ mutual recusion """ - return self.join1 - -#? str() -PropClass("").ret -#? [] -PropClass().ret. - -#? str() -PropClass("").ret2 -#? -PropClass().ret2 - -#? int() -PropClass(1).nested -#? [] -PropClass().nested. - -#? -PropClass(1).nested2 -#? [] -PropClass().nested2. - -#? -PropClass(1).join1 -# ----------------- -# staticmethod/classmethod -# ----------------- - -class E(object): - a = '' - def __init__(self, a): - self.a = a - - def f(x): - return x - f = staticmethod(f) - #? - f.__func - - @staticmethod - def g(x): - return x - - def s(cls, x): - return x - s = classmethod(s) - - @classmethod - def t(cls, x): - return x - - @classmethod - def u(cls, x): - return cls.a - -e = E(1) -#? int() -e.f(1) -#? int() -E.f(1) -#? int() -e.g(1) -#? int() -E.g(1) - -#? int() -e.s(1) -#? int() -E.s(1) -#? int() -e.t(1) -#? int() -E.t(1) - -#? str() -e.u(1) -#? str() -E.u(1) - -# ----------------- -# Conditions -# ----------------- - -from functools import partial - - -class Memoize(): - def __init__(self, func): - self.func = func - - def __get__(self, obj, objtype): - if obj is None: - return self.func - - return partial(self, obj) - - def __call__(self, *args, **kwargs): - # We don't do caching here, but that's what would normally happen. - return self.func(*args, **kwargs) - - -class MemoizeTest(): - def __init__(self, x): - self.x = x - - @Memoize - def some_func(self): - return self.x - - -#? int() -MemoizeTest(10).some_func() -# Now also call the same function over the class (see if clause above). -#? float() -MemoizeTest.some_func(MemoizeTest(10.0)) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/docstring.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/docstring.py deleted file mode 100644 index 88db52d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/docstring.py +++ /dev/null @@ -1,246 +0,0 @@ -""" Test docstrings in functions and classes, which are used to infer types """ - -# ----------------- -# sphinx style -# ----------------- -def sphinxy(a, b, c, d, x): - """ asdfasdf - :param a: blablabla - :type a: str - :type b: (str, int) - :type c: random.Random - :type d: :class:`random.Random` - :param str x: blablabla - :rtype: dict - """ - #? str() - a - #? str() - b[0] - #? int() - b[1] - #? ['seed'] - c.seed - #? ['seed'] - d.seed - #? ['lower'] - x.lower - -#? dict() -sphinxy() - -# wrong declarations -def sphinxy2(a, b, x): - """ - :param a: Forgot type declaration - :type a: - :param b: Just something - :type b: `` - :param x: Just something without type - :rtype: - """ - #? - a - #? - b - #? - x - -#? -sphinxy2() - - -def sphinxy_param_type_wrapped(a): - """ - :param str a: - Some description wrapped onto the next line with no space after the - colon. - """ - #? str() - a - - -# local classes -> github #370 -class ProgramNode(): - pass - -def local_classes(node, node2): - """ - :type node: ProgramNode - ... and the class definition after this func definition: - :type node2: ProgramNode2 - """ - #? ProgramNode() - node - #? ProgramNode2() - node2 - -class ProgramNode2(): - pass - - -def list_with_non_imports(lst): - """ - Should be able to work with tuples and lists and still import stuff. - - :type lst: (random.Random, [collections.defaultdict, ...]) - """ - #? ['seed'] - lst[0].seed - - import collections as col - # use some weird index - #? col.defaultdict() - lst[1][10] - - -def two_dots(a): - """ - :type a: json.decoder.JSONDecoder - """ - #? ['raw_decode'] - a.raw_decode - - -# sphinx returns -def return_module_object(): - """ - :rtype: :class:`random.Random` - """ - -#? ['seed'] -return_module_object().seed - - -# ----------------- -# epydoc style -# ----------------- -def epydoc(a, b): - """ asdfasdf - @type a: str - @param a: blablabla - @type b: (str, int) - @param b: blablah - @rtype: list - """ - #? str() - a - #? str() - b[0] - - #? int() - b[1] - -#? list() -epydoc() - - -# Returns with param type only -def rparam(a,b): - """ - @type a: str - """ - return a - -#? str() -rparam() - - -# Composite types -def composite(): - """ - @rtype: (str, int, dict) - """ - -x, y, z = composite() -#? str() -x -#? int() -y -#? dict() -z - - -# Both docstring and calculated return type -def both(): - """ - @rtype: str - """ - return 23 - -#? str() int() -both() - -class Test(object): - def __init__(self): - self.teststr = "" - """ - # jedi issue #210 - """ - def test(self): - #? ['teststr'] - self.teststr - -# ----------------- -# statement docstrings -# ----------------- -d = '' -""" bsdf """ -#? str() -d.upper() - -# ----------------- -# class docstrings -# ----------------- - -class InInit(): - def __init__(self, foo): - """ - :type foo: str - """ - #? str() - foo - - -class InClass(): - """ - :type foo: str - """ - def __init__(self, foo): - #? str() - foo - - -class InBoth(): - """ - :type foo: str - """ - def __init__(self, foo): - """ - :type foo: int - """ - #? str() int() - foo - - -def __init__(foo): - """ - :type foo: str - """ - #? str() - foo - - -# ----------------- -# Renamed imports (#507) -# ----------------- - -import datetime -from datetime import datetime as datetime_imported - -def import_issues(foo): - """ - @type foo: datetime_imported - """ - #? datetime.datetime() - foo diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/dynamic_arrays.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/dynamic_arrays.py deleted file mode 100644 index 9be530f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/dynamic_arrays.py +++ /dev/null @@ -1,310 +0,0 @@ -""" -Checking for ``list.append`` and all the other possible array modifications. -""" -# ----------------- -# list.append -# ----------------- -arr = [] -for a in [1,2]: - arr.append(a); - -arr.append # should not cause an exception -arr.append() # should not cause an exception - -#? int() -arr[10] - -arr = [tuple()] -for a in [1,2]: - arr.append(a); - -#? int() tuple() -arr[10] -#? int() -arr[10].index() - -arr = list([]) -arr.append(1) -#? int() -arr[0] - -# ----------------- -# list.insert -# ----------------- -arr = [""] -arr.insert(0, 1.0) - -# on exception due to this, please! -arr.insert(0) -arr.insert() - -#? float() str() -arr[10] - -for a in arr: - #? float() str() - a - -#? float() str() -list(arr)[10] - -# ----------------- -# list.extend / set.update -# ----------------- - -arr = [1.0] -arr.extend([1,2,3]) -arr.extend([]) -arr.extend("") # should ignore - -#? float() int() -arr[100] - -a = set(arr) -a.update(list(["", 1])) - -#? float() int() str() -list(a)[0] -# ----------------- -# set/list initialized as functions -# ----------------- - -st = set() -st.add(1) - -#? int() -for s in st: s - -lst = list() -lst.append(1) - -#? int() -for i in lst: i - -# ----------------- -# renames / type changes -# ----------------- -arr = [] -arr2 = arr -arr2.append('') -#? str() -arr2[0] - - -lst = [1] -lst.append(1.0) -s = set(lst) -s.add("") -lst = list(s) -lst.append({}) - -#? dict() int() float() str() -lst[0] - -# should work with tuple conversion, too. -#? dict() int() float() str() -tuple(lst)[0] - -# but not with an iterator -#? -iter(lst)[0] - -# ----------------- -# complex including += -# ----------------- -class C(): pass -class D(): pass -class E(): pass -lst = [1] -lst.append(1.0) -lst += [C] -s = set(lst) -s.add("") -s += [D] -lst = list(s) -lst.append({}) -lst += [E] - -##? dict() int() float() str() C D E -lst[0] - -# ----------------- -# functions -# ----------------- - -def arr_append(arr4, a): - arr4.append(a) - -def add_to_arr(arr2, a): - arr2.append(a) - return arr2 - -def app(a): - arr3.append(a) - -arr3 = [1.0] -res = add_to_arr(arr3, 1) -arr_append(arr3, 'str') -app(set()) - -#? float() str() int() set() -arr3[10] - -#? float() str() int() set() -res[10] - -# ----------------- -# returns, special because the module dicts are not correct here. -# ----------------- -def blub(): - a = [] - a.append(1.0) - #? float() - a[0] - return a - -#? float() -blub()[0] - -# list with default -def blub(): - a = list([1]) - a.append(1.0) - return a - -#? int() float() -blub()[0] - -# empty list -def blub(): - a = list() - a.append(1.0) - return a -#? float() -blub()[0] - -# with if -def blub(): - if 1: - a = [] - a.append(1.0) - return a - -#? float() -blub()[0] - -# with else clause -def blub(): - if random.choice([0, 1]): - 1 - else: - a = [] - a.append(1) - return a - -#? int() -blub()[0] -# ----------------- -# returns, the same for classes -# ----------------- -class C(): - def blub(self, b): - if 1: - a = [] - a.append(b) - return a - - def blub2(self): - """ mapper function """ - a = self.blub(1.0) - #? float() - a[0] - return a - - def literal_arr(self, el): - self.a = [] - self.a.append(el) - #? int() - self.a[0] - return self.a - - def list_arr(self, el): - self.b = list([]) - self.b.append(el) - #? float() - self.b[0] - return self.b - -#? int() -C().blub(1)[0] -#? float() -C().blub2(1)[0] - -#? int() -C().a[0] -#? int() -C().literal_arr(1)[0] - -#? float() -C().b[0] -#? float() -C().list_arr(1.0)[0] - -# ----------------- -# array recursions -# ----------------- - -a = set([1.0]) -a.update(a) -a.update([1]) - -#? float() int() -list(a)[0] - -def first(a): - b = [] - b.append(a) - b.extend(second(a)) - return list(b) - -def second(a): - b = [] - b.extend(first(a)) - return list(b) - -#? float() -first(1.0)[0] - -def third(): - b = [] - b.extend - extend() - b.extend(first()) - return list(b) -#? -third()[0] - - -# ----------------- -# set.add -# ----------------- -# Set literals are not valid in 2.6. -# python >= 2.7 -st = {1.0} -for a in [1,2]: - st.add(a) - -st.append('') # lists should not have an influence - -st.add # should not cause an exception -st.add() - -st = {1.0} -st.add(1) -lst = list(st) - -lst.append('') - -#? float() int() str() -lst[0] - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/dynamic_params.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/dynamic_params.py deleted file mode 100644 index 8af1730..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/dynamic_params.py +++ /dev/null @@ -1,134 +0,0 @@ -""" -This is used for dynamic object completion. -Jedi tries to guess param types with a backtracking approach. -""" -def func(a, default_arg=2): - #? int() - default_arg - #? int() str() - return a - -#? int() -func(1) - -func - -int(1) + (int(2))+ func('') - -# Again the same function, but with another call. -def func(a): - #? float() - return a - -func(1.0) - -# Again the same function, but with no call. -def func(a): - #? - return a - -def func(a): - #? float() - return a -str(func(1.0)) - -# ----------------- -# *args, **args -# ----------------- -def arg(*args): - #? tuple() - args - #? int() - args[0] - -arg(1,"") -# ----------------- -# decorators -# ----------------- -def def_func(f): - def wrapper(*args, **kwargs): - return f(*args, **kwargs) - return wrapper - -@def_func -def func(c): - #? str() - return c - -#? str() -func("something") - -@def_func -def func(c=1): - #? float() - return c - -func(1.0) - -def tricky_decorator(func): - def wrapper(*args): - return func(1, *args) - - return wrapper - - -@tricky_decorator -def func(a, b): - #? int() - a - #? float() - b - -func(1.0) - -# Needs to be here, because in this case func is an import -> shouldn't lead to -# exceptions. -import sys as func -func.sys - -# ----------------- -# classes -# ----------------- - -class A(): - def __init__(self, a): - #? str() - a - -A("s") - -class A(): - def __init__(self, a): - #? int() - a - self.a = a - - def test(self, a): - #? float() - a - self.c = self.test2() - - def test2(self): - #? int() - return self.a - - def test3(self): - #? int() - self.test2() - #? int() - self.c - -A(3).test(2.0) -A(3).test2() - - -# ----------------- -# comprehensions -# ----------------- - -def from_comprehension(foo): - #? int() float() - return foo - -[from_comprehension(1.0) for n in (1,)] -[from_comprehension(n) for n in (1,)] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/flow_analysis.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/flow_analysis.py deleted file mode 100644 index af292b4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/flow_analysis.py +++ /dev/null @@ -1,298 +0,0 @@ -# ----------------- -# First a few name resolution things -# ----------------- - -x = 3 -if NOT_DEFINED: - x = '' -#? 6 int() -elif x: - pass -else: - #? int() - x - -x = 1 -try: - x = '' -#? 8 int() str() -except x: - #? 5 int() str() - x - x = 1.0 -else: - #? 5 int() str() - x - x = list -finally: - #? 5 int() str() float() list - x - x = tuple - - -# ----------------- -# Return checks -# ----------------- - -def foo(x): - if 1.0: - return 1 - else: - return '' - -#? int() -foo(1) - - -# Exceptions are not analyzed. So check both if branches -def try_except(x): - try: - if 0: - return 1 - else: - return '' - except AttributeError: - return 1.0 - -#? float() str() -try_except(1) - - -# Exceptions are not analyzed. So check both if branches -def try_except(x): - try: - if 0: - return 1 - else: - return '' - except AttributeError: - return 1.0 - -#? float() str() -try_except(1) - - -# ----------------- -# elif -# ----------------- - -def elif_flows1(x): - if False: - return 1 - elif True: - return 1.0 - else: - return '' - -#? float() -elif_flows1(1) - - -def elif_flows2(x): - try: - if False: - return 1 - elif 0: - return 1.0 - else: - return '' - except ValueError: - return set - -#? str() set -elif_flows2(1) - - -def elif_flows3(x): - try: - if True: - return 1 - elif 0: - return 1.0 - else: - return '' - except ValueError: - return set - -#? int() set -elif_flows3(1) - -# ----------------- -# mid-difficulty if statements -# ----------------- -def check(a): - if a is None: - return 1 - return '' - return set - -#? int() -check(None) -#? str() -check('asb') - -a = list -if 2 == True: - a = set -elif 1 == True: - a = 0 - -#? int() -a -if check != 1: - a = '' -#? str() -a -if check == check: - a = list -#? list -a -if check != check: - a = set -else: - a = dict -#? dict -a -if not (check is not check): - a = 1 -#? int() -a - - -# ----------------- -# name resolution -# ----------------- - -a = list -def elif_name(x): - try: - if True: - a = 1 - elif 0: - a = 1.0 - else: - return '' - except ValueError: - a = x - return a - -#? int() set -elif_name(set) - -if 0: - a = '' -else: - a = int - -#? int -a - -# ----------------- -# isinstance -# ----------------- - -class A(): pass - -def isinst(x): - if isinstance(x, A): - return dict - elif isinstance(x, int) and x == 1 or x is True: - return set - elif isinstance(x, (float, reversed)): - return list - elif not isinstance(x, str): - return tuple - return 1 - -#? dict -isinst(A()) -#? set -isinst(True) -#? set -isinst(1) -#? tuple -isinst(2) -#? list -isinst(1.0) -#? tuple -isinst(False) -#? int() -isinst('') - -# ----------------- -# flows that are not reachable should be able to access parent scopes. -# ----------------- - -foobar = '' - -if 0: - within_flow = 1.0 - #? float() - within_flow - #? str() - foobar - if 0: - nested = 1 - #? int() - nested - #? float() - within_flow - #? str() - foobar - #? - nested - -if False: - in_false = 1 - #? ['in_false'] - in_false - -# ----------------- -# True objects like modules -# ----------------- - -class X(): - pass -if X: - a = 1 -else: - a = '' -#? int() -a - - -# ----------------- -# Recursion issues -# ----------------- - -def possible_recursion_error(filename): - if filename == 'a': - return filename - # It seems like without the brackets there wouldn't be a RecursionError. - elif type(filename) == str: - return filename - - -if NOT_DEFINED: - s = str() -else: - s = str() -#? str() -possible_recursion_error(s) - - -# ----------------- -# In combination with imports -# ----------------- - -from import_tree import flow_import - -if 1 == flow_import.env: - a = 1 -elif 2 == flow_import.env: - a = '' -elif 3 == flow_import.env: - a = 1.0 - -#? int() str() -a diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/functions.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/functions.py deleted file mode 100644 index 893e4a3..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/functions.py +++ /dev/null @@ -1,481 +0,0 @@ -def x(): - return - -#? None -x() - -def array(first_param): - #? ['first_param'] - first_param - return list() - -#? [] -array.first_param -#? [] -array.first_param. -func = array -#? [] -func.first_param - -#? list() -array() - -#? ['array'] -arr - - -def inputs(param): - return param - -#? list -inputs(list) - -def variable_middle(): - var = 3 - return var - -#? int() -variable_middle() - -def variable_rename(param): - var = param - return var - -#? int() -variable_rename(1) - -def multi_line_func(a, # comment blabla - - b): - return b - -#? str() -multi_line_func(1,'') - -def multi_line_call(b): - return b - - -multi_line_call( -#? int() - b=1) - - -# nothing after comma -def asdf(a): - return a - -x = asdf(a=1, - ) -#? int() -x - -# ----------------- -# double execution -# ----------------- -def double_exe(param): - return param - -#? str() -variable_rename(double_exe)("") - -# -> shouldn't work (and throw no error) -#? [] -variable_rename(list())(). -#? [] -variable_rename(1)(). - -# ----------------- -# recursions (should ignore) -# ----------------- -def recursion(a, b): - if a: - return b - else: - return recursion(a+".", b+1) - -# Does not also return int anymore, because we now support operators in simple cases. -#? float() -recursion("a", 1.0) - -def other(a): - return recursion2(a) - -def recursion2(a): - if random.choice([0, 1]): - return other(a) - else: - if random.choice([0, 1]): - return recursion2("") - else: - return a - -#? int() str() -recursion2(1) - -# ----------------- -# ordering -# ----------------- - -def a(): - #? int() - b() - return b() - -def b(): - return 1 - -#? int() -a() - -# ----------------- -# keyword arguments -# ----------------- - -def func(a=1, b=''): - return a, b - -exe = func(b=list, a=tuple) -#? tuple -exe[0] - -#? list -exe[1] - -# ----------------- -# default arguments -# ----------------- - -#? int() -func()[0] -#? str() -func()[1] -#? float() -func(1.0)[0] -#? str() -func(1.0)[1] - - -#? float() -func(a=1.0)[0] -#? str() -func(a=1.0)[1] -#? int() -func(b=1.0)[0] -#? float() -func(b=1.0)[1] -#? list -func(a=list, b=set)[0] -#? set -func(a=list, b=set)[1] - - -def func_default(a, b=1): - return a, b - - -def nested_default(**kwargs): - return func_default(**kwargs) - -#? float() -nested_default(a=1.0)[0] -#? int() -nested_default(a=1.0)[1] -#? str() -nested_default(a=1.0, b='')[1] - -# Defaults should only work if they are defined before - not after. -def default_function(a=default): - #? - return a - -#? -default_function() - -default = int() - -def default_function(a=default): - #? int() - return a - -#? int() -default_function() - - -# ----------------- -# closures -# ----------------- -def a(): - l = 3 - def func_b(): - l = '' - #? str() - l - #? ['func_b'] - func_b - #? int() - l - -# ----------------- -# *args -# ----------------- - -def args_func(*args): - #? tuple() - return args - -exe = args_func(1, "") -#? int() -exe[0] -#? str() -exe[1] - -# illegal args (TypeError) -#? -args_func(*1)[0] -# iterator -#? int() -args_func(*iter([1]))[0] - -# different types -e = args_func(*[1+"", {}]) -#? int() str() -e[0] -#? dict() -e[1] - -_list = [1,""] -exe2 = args_func(_list)[0] - -#? str() -exe2[1] - -exe3 = args_func([1,""])[0] - -#? str() -exe3[1] - -def args_func(arg1, *args): - return arg1, args - -exe = args_func(1, "", list) -#? int() -exe[0] -#? tuple() -exe[1] -#? list -exe[1][1] - - -# In a dynamic search, both inputs should be given. -def simple(a): - #? int() str() - return a -def xargs(*args): - return simple(*args) - -xargs(1) -xargs('') - - -# *args without a self symbol -def memoize(func): - def wrapper(*args, **kwargs): - return func(*args, **kwargs) - return wrapper - - -class Something(): - @memoize - def x(self, a, b=1): - return a - -#? int() -Something().x(1) - - -# ----------------- -# ** kwargs -# ----------------- -def kwargs_func(**kwargs): - #? ['keys'] - kwargs.keys - #? dict() - return kwargs - -exe = kwargs_func(a=3,b=4.0) -#? dict() -exe -#? int() -exe['a'] -#? float() -exe['b'] -#? int() float() -exe['c'] - -a = 'a' -exe2 = kwargs_func(**{a:3, - 'b':4.0}) -#? int() -exe2['a'] -#? float() -exe2['b'] -#? int() float() -exe2['c'] - -# ----------------- -# *args / ** kwargs -# ----------------- - -def func_without_call(*args, **kwargs): - #? tuple() - args - #? dict() - kwargs - -def fu(a=1, b="", *args, **kwargs): - return a, b, args, kwargs - -exe = fu(list, 1, "", c=set, d="") - -#? list -exe[0] -#? int() -exe[1] -#? tuple() -exe[2] -#? str() -exe[2][0] -#? dict() -exe[3] -#? set -exe[3]['c'] - - -def kwargs_iteration(**kwargs): - return kwargs - -for x in kwargs_iteration(d=3): - #? float() - {'d': 1.0, 'c': '1'}[x] - - -# ----------------- -# nested *args -# ----------------- -def function_args(a, b, c): - return b - -def nested_args(*args): - return function_args(*args) - -def nested_args2(*args, **kwargs): - return nested_args(*args) - -#? int() -nested_args('', 1, 1.0, list) -#? [] -nested_args(''). - -#? int() -nested_args2('', 1, 1.0) -#? [] -nested_args2(''). - -# ----------------- -# nested **kwargs -# ----------------- -def nested_kw(**kwargs1): - return function_args(**kwargs1) - -def nested_kw2(**kwargs2): - return nested_kw(**kwargs2) - -# invalid command, doesn't need to return anything -#? -nested_kw(b=1, c=1.0, list) -#? int() -nested_kw(b=1) -# invalid command, doesn't need to return anything -#? -nested_kw(d=1.0, b=1, list) -#? int() -nested_kw(a=3.0, b=1) -#? int() -nested_kw(b=1, a=r"") -#? [] -nested_kw(1, ''). -#? [] -nested_kw(a=''). - -#? int() -nested_kw2(b=1) -#? int() -nested_kw2(b=1, c=1.0) -#? int() -nested_kw2(c=1.0, b=1) -#? [] -nested_kw2(''). -#? [] -nested_kw2(a=''). -#? [] -nested_kw2('', b=1). - -# ----------------- -# nested *args/**kwargs -# ----------------- -def nested_both(*args, **kwargs): - return function_args(*args, **kwargs) - -def nested_both2(*args, **kwargs): - return nested_both(*args, **kwargs) - -# invalid commands, may return whatever. -#? list -nested_both('', b=1, c=1.0, list) -#? list -nested_both('', c=1.0, b=1, list) - -#? [] -nested_both(''). - -#? int() -nested_both2('', b=1, c=1.0) -#? int() -nested_both2('', c=1.0, b=1) -#? [] -nested_both2(''). - -# ----------------- -# nested *args/**kwargs with a default arg -# ----------------- -def function_def(a, b, c): - return a, b - -def nested_def(a, *args, **kwargs): - return function_def(a, *args, **kwargs) - -def nested_def2(*args, **kwargs): - return nested_def(*args, **kwargs) - -#? str() -nested_def2('', 1, 1.0)[0] -#? str() -nested_def2('', b=1, c=1.0)[0] -#? str() -nested_def2('', c=1.0, b=1)[0] -#? int() -nested_def2('', 1, 1.0)[1] -#? int() -nested_def2('', b=1, c=1.0)[1] -#? int() -nested_def2('', c=1.0, b=1)[1] -#? [] -nested_def2('')[1]. - -# ----------------- -# magic methods -# ----------------- -def a(): pass -#? ['__closure__'] -a.__closure__ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/generators.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/generators.py deleted file mode 100644 index 2327b18..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/generators.py +++ /dev/null @@ -1,231 +0,0 @@ -# ----------------- -# yield statement -# ----------------- -def gen(): - if random.choice([0, 1]): - yield 1 - else: - yield "" - -gen_exe = gen() -#? int() str() -next(gen_exe) - -#? int() str() list -next(gen_exe, list) - - -def gen_ret(value): - yield value - -#? int() -next(gen_ret(1)) - -#? [] -next(gen_ret()). - -# generators evaluate to true if cast by bool. -a = '' -if gen_ret(): - a = 3 -#? int() -a - - -# ----------------- -# generators should not be indexable -# ----------------- -def get(param): - if random.choice([0, 1]): - yield 1 - else: - yield "" - -#? [] -get()[0]. - -# ----------------- -# __iter__ -# ----------------- -for a in get(): - #? int() str() - a - - -class Get(): - def __iter__(self): - if random.choice([0, 1]): - yield 1 - else: - yield "" - -b = [] -for a in Get(): - #? int() str() - a - b += [a] - -#? list() -b -#? int() str() -b[0] - -g = iter(Get()) -#? int() str() -next(g) - -g = iter([1.0]) -#? float() -next(g) - - -# ----------------- -# __next__ -# ----------------- -class Counter: - def __init__(self, low, high): - self.current = low - self.high = high - - def __iter__(self): - return self - - def next(self): - """ need to have both __next__ and next, because of py2/3 testing """ - return self.__next__() - - def __next__(self): - if self.current > self.high: - raise StopIteration - else: - self.current += 1 - return self.current - 1 - - -for c in Counter(3, 8): - #? int() - print c - - -# ----------------- -# tuple assignments -# ----------------- -def gen(): - if random.choice([0,1]): - yield 1, "" - else: - yield 2, 1.0 - - -a, b = next(gen()) -#? int() -a -#? str() float() -b - - -def simple(): - if random.choice([0, 1]): - yield 1 - else: - yield "" - -a, b = simple() -#? int() str() -a -# For now this is ok. -#? -b - - -def simple2(): - yield 1 - yield "" - -a, b = simple2() -#? int() -a -#? str() -b - -a, = (a for a in [1]) -#? int() -a - -# ----------------- -# More complicated access -# ----------------- - -# `close` is a method wrapper. -#? ['__call__'] -gen().close.__call__ - -#? -gen().throw() - -#? ['co_consts'] -gen().gi_code.co_consts - -#? [] -gen.gi_code.co_consts - -# `send` is also a method wrapper. -#? ['__call__'] -gen().send.__call__ - -#? tuple() -gen().send() - -#? -gen()() - -# ----------------- -# empty yield -# ----------------- - -def x(): - yield - -#? None -next(x()) -#? gen() -x() - -def x(): - for i in range(3): - yield - -#? None -next(x()) - -# ----------------- -# yield in expression -# ----------------- - -def x(): - a= [(yield 1)] - -#? int() -next(x()) - -# ----------------- -# yield from -# ----------------- - -# python >= 3.3 - -def yield_from(): - yield from iter([1]) - -#? int() -next(yield_from()) - -def yield_from_multiple(): - yield from iter([1]) - yield str() - -x, y = yield_from_multiple() -#? int() -x -#? str() -y diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/goto.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/goto.py deleted file mode 100644 index adff012..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/goto.py +++ /dev/null @@ -1,231 +0,0 @@ -# goto_assignments command tests are different in syntax - -definition = 3 -#! 0 ['a = definition'] -a = definition - -#! [] -b -#! ['a = definition'] -a - -b = a -c = b -#! ['c = b'] -c - -cd = 1 -#! 1 ['cd = c'] -cd = c -#! 0 ['cd = e'] -cd = e - -#! ['module math'] -import math -#! ['module math'] -math - -#! ['module math'] -b = math -#! ['b = math'] -b - -#! 18 ['foo = 10'] -foo = 10;print(foo) - -# ----------------- -# classes -# ----------------- -class C(object): - def b(self): - #! ['b = math'] - b - #! ['def b'] - self.b - #! 14 ['def b'] - self.b() - #! 11 ['param self'] - self.b - return 1 - - #! ['def b'] - b - -#! ['b = math'] -b - -#! ['def b'] -C.b -#! ['def b'] -C().b -#! 0 ['class C'] -C().b -#! 0 ['class C'] -C().b - -D = C -#! ['def b'] -D.b -#! ['def b'] -D().b - -#! 0 ['D = C'] -D().b -#! 0 ['D = C'] -D().b - -def c(): - return '' - -#! ['def c'] -c -#! 0 ['def c'] -c() - - -class ClassVar(): - x = 3 - -#! ['x = 3'] -ClassVar.x -#! ['x = 3'] -ClassVar().x - -# before assignments -#! 10 ['x = 3'] -ClassVar.x = '' -#! 12 ['x = 3'] -ClassVar().x = '' - -# Recurring use of the same var name, github #315 -def f(t=None): - #! 9 ['param t=None'] - t = t or 1 - - -class X(): - pass - -#! 3 [] -X(foo=x) - -# ----------------- -# imports -# ----------------- - -#! ['module import_tree'] -import import_tree -#! ["a = ''"] -import_tree.a - -#! ['module mod1'] -import import_tree.mod1 -#! ['a = 1'] -import_tree.mod1.a - -#! ['module pkg'] -import import_tree.pkg -#! ['a = list'] -import_tree.pkg.a - -#! ['module mod1'] -import import_tree.pkg.mod1 -#! ['a = 1.0'] -import_tree.pkg.mod1.a -#! ["a = ''"] -import_tree.a - -#! ['module mod1'] -from import_tree.pkg import mod1 -#! ['a = 1.0'] -mod1.a - -#! ['module mod1'] -from import_tree import mod1 -#! ['a = 1'] -mod1.a - -#! ['a = 1.0'] -from import_tree.pkg.mod1 import a - -#! ['module os'] -from .imports import os - -#! ['some_variable = 1'] -from . import some_variable - -# ----------------- -# anonymous classes -# ----------------- -def func(): - class A(): - def b(self): - return 1 - return A() - -#! 8 ['def b'] -func().b() - -# ----------------- -# on itself -# ----------------- - -#! 7 ['class ClassDef'] -class ClassDef(): - """ abc """ - pass - -# ----------------- -# params -# ----------------- - -param = ClassDef -#! 8 ['param param'] -def ab1(param): pass -#! 9 ['param param'] -def ab2(param): pass -#! 11 ['param = ClassDef'] -def ab3(a=param): pass - -ab1(ClassDef);ab2(ClassDef);ab3(ClassDef) - -# ----------------- -# for loops -# ----------------- - -for i in range(1): - #! ['for i in range(1): i'] - i - -for key, value in [(1,2)]: - #! ['for key, value in [(1,2)]: key'] - key - -for i in []: - #! ['for i in []: i'] - i - -# ----------------- -# decorator -# ----------------- -def dec(dec_param=3): - pass - -#! 8 ['param dec_param=3'] -@dec(dec_param=5) -def y(): - pass - -class ClassDec(): - def class_func(func): - return func - -#! 14 ['def class_func'] -@ClassDec.class_func -def x(): - pass - -#! 2 ['class ClassDec'] -@ClassDec.class_func -def z(): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/__init__.py deleted file mode 100644 index 5cbbcd7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -a = '' - -from . import invisible_pkg - -the_pkg = invisible_pkg - -invisible_pkg = 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/classes.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/classes.py deleted file mode 100644 index 23b088c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/classes.py +++ /dev/null @@ -1,10 +0,0 @@ -blub = 1 - -class Config2(): - pass - - -class BaseClass(): - mode = Config2() - if isinstance(whaat, int): - mode2 = whaat diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/flow_import.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/flow_import.py deleted file mode 100644 index a0a779e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/flow_import.py +++ /dev/null @@ -1,4 +0,0 @@ -if name: - env = 1 -else: - env = 2 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/invisible_pkg.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/invisible_pkg.py deleted file mode 100644 index 9c78ce2..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/invisible_pkg.py +++ /dev/null @@ -1,7 +0,0 @@ -""" -It should not be possible to import this pkg except for the import_tree itself, -because it is overwritten there. (It would be possible with a sys.path -modification, though). -""" - -foo = 1.0 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/mod1.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/mod1.py deleted file mode 100644 index bd696d6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/mod1.py +++ /dev/null @@ -1,4 +0,0 @@ -a = 1 -from import_tree.random import a as c - -foobarbaz = 3.0 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/mod2.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/mod2.py deleted file mode 100644 index 19914f5..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/mod2.py +++ /dev/null @@ -1 +0,0 @@ -from . import mod1 as fake diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/pkg/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/pkg/__init__.py deleted file mode 100644 index 480f222..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/pkg/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -a = list - -from math import * diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/pkg/mod1.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/pkg/mod1.py deleted file mode 100644 index fe1d27f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/pkg/mod1.py +++ /dev/null @@ -1,3 +0,0 @@ -a = 1.0 - -from ..random import foobar diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/random.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/random.py deleted file mode 100644 index 7a34c4e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/random.py +++ /dev/null @@ -1,6 +0,0 @@ -""" -Here because random is also a builtin module. -""" -a = set - -foobar = 0 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/recurse_class1.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/recurse_class1.py deleted file mode 100644 index 773408c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/recurse_class1.py +++ /dev/null @@ -1,5 +0,0 @@ -import recurse_class2 - -class C(recurse_class2.C): - def a(self): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/recurse_class2.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/recurse_class2.py deleted file mode 100644 index 42f84ef..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/recurse_class2.py +++ /dev/null @@ -1,4 +0,0 @@ -import recurse_class1 - -class C(recurse_class1.C): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/rename1.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/rename1.py deleted file mode 100644 index bdc3315..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/rename1.py +++ /dev/null @@ -1,3 +0,0 @@ -""" used for renaming tests """ - -abc = 3 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/rename2.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/rename2.py deleted file mode 100644 index 8423895..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/import_tree/rename2.py +++ /dev/null @@ -1,6 +0,0 @@ -""" used for renaming tests """ - - -from rename1 import abc - -abc diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/imports.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/imports.py deleted file mode 100644 index 5c8626f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/imports.py +++ /dev/null @@ -1,295 +0,0 @@ -# ----------------- -# own structure -# ----------------- - -# do separate scopes -def scope_basic(): - from import_tree import mod1 - - #? int() - mod1.a - - #? [] - import_tree.a - - #? [] - import_tree.mod1 - - import import_tree - #? str() - import_tree.a - - -def scope_pkg(): - import import_tree.mod1 - - #? str() - import_tree.a - - #? ['mod1'] - import_tree.mod1 - - #? int() - import_tree.mod1.a - -def scope_nested(): - import import_tree.pkg.mod1 - - #? str() - import_tree.a - - #? list - import_tree.pkg.a - - #? ['sqrt'] - import_tree.pkg.sqrt - - #? ['pkg'] - import_tree.p - - #? float() - import_tree.pkg.mod1.a - #? ['a', 'foobar', '__name__', '__package__', '__file__', '__doc__'] - a = import_tree.pkg.mod1. - - import import_tree.random - #? set - import_tree.random.a - -def scope_nested2(): - """Multiple modules should be indexable, if imported""" - import import_tree.mod1 - import import_tree.pkg - #? ['mod1'] - import_tree.mod1 - #? ['pkg'] - import_tree.pkg - - # With the latest changes this completion also works, because submodules - # are always included (some nested import structures lead to this, - # typically). - #? ['rename1'] - import_tree.rename1 - -def scope_from_import_variable(): - """ - All of them shouldn't work, because "fake" imports don't work in python - without the use of ``sys.modules`` modifications (e.g. ``os.path`` see also - github issue #213 for clarification. - """ - a = 3 - #? - from import_tree.mod2.fake import a - #? - from import_tree.mod2.fake import c - - #? - a - #? - c - -def scope_from_import_variable_with_parenthesis(): - from import_tree.mod2.fake import ( - a, foobarbaz - ) - - #? - a - #? - foobarbaz - # shouldn't complete, should still list the name though. - #? ['foobarbaz'] - foobarbaz - - -def as_imports(): - from import_tree.mod1 import a as xyz - #? int() - xyz - import not_existant, import_tree.mod1 as foo - #? int() - foo.a - import import_tree.mod1 as bar - #? int() - bar.a - - -def test_import_priorities(): - """ - It's possible to overwrite import paths in an ``__init__.py`` file, by - just assigining something there. - - See also #536. - """ - from import_tree import the_pkg, invisible_pkg - #? int() - invisible_pkg - # In real Python, this would be the module, but it's not, because Jedi - # doesn't care about most stateful issues such as __dict__, which it would - # need to, to do this in a correct way. - #? int() - the_pkg - # Importing foo is still possible, even though inivisible_pkg got changed. - #? float() - from import_tree.invisible_pkg import foo - - -# ----------------- -# std lib modules -# ----------------- -import tokenize -#? ['tok_name'] -tokenize.tok_name - -from pyclbr import * - -#? ['readmodule_ex'] -readmodule_ex -import os - -#? ['dirname'] -os.path.dirname - -from os.path import ( - expanduser -) - -#? os.path.expanduser -expanduser - -from itertools import (tee, - islice) -#? ['islice'] -islice - -from functools import (partial, wraps) -#? ['wraps'] -wraps - -from keyword import kwlist, \ - iskeyword -#? ['kwlist'] -kwlist - -#? [] -from keyword import not_existing1, not_existing2 - -from tokenize import io -tokenize.generate_tokens - -# ----------------- -# builtins -# ----------------- - -import sys -#? ['prefix'] -sys.prefix - -#? ['append'] -sys.path.append - -from math import * -#? ['cos', 'cosh'] -cos - -def func_with_import(): - import time - return time - -#? ['sleep'] -func_with_import().sleep - -# ----------------- -# relative imports -# ----------------- - -from .import_tree import mod1 -#? int() -mod1.a - -from ..import_tree import mod1 -#? -mod1.a - -from .......import_tree import mod1 -#? -mod1.a - -from .. import helpers -#? int() -helpers.sample_int - -from ..helpers import sample_int as f -#? int() -f - -from . import run -#? [] -run. - -from . import import_tree as imp_tree -#? str() -imp_tree.a - -from . import datetime as mod1 -#? [] -mod1. - -# self import -# this can cause recursions -from imports import * - -# ----------------- -# packages -# ----------------- - -from import_tree.mod1 import c -#? set -c - -from import_tree import recurse_class1 - -#? ['a'] -recurse_class1.C.a -# github #239 RecursionError -#? ['a'] -recurse_class1.C().a - -# ----------------- -# Jedi debugging -# ----------------- - -# memoizing issues (check git history for the fix) -import not_existing_import - -if not_existing_import: - a = not_existing_import -else: - a = not_existing_import -#? -a - -# ----------------- -# module underscore descriptors -# ----------------- - -def underscore(): - import keyword - #? ['__file__'] - keyword.__file__ - #? str() - keyword.__file__ - - # Does that also work for the our own module? - #? ['__file__'] - __file__ - - -# ----------------- -# complex relative imports #784 -# ----------------- -def relative(): - #? ['foobar'] - from import_tree.pkg.mod1 import foobar - #? int() - foobar diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/invalid.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/invalid.py deleted file mode 100644 index 7c047e6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/invalid.py +++ /dev/null @@ -1,214 +0,0 @@ -""" -This file is less about the results and much more about the fact, that no -exception should be thrown. - -Basically this file could change depending on the current implementation. But -there should never be any errors. -""" - -# wait until keywords are out of definitions (pydoc function). -##? 5 -'s'() - -#? [] -str()).upper - -# ----------------- -# funcs -# ----------------- -def asdf(a or b): # multiple param names - return a - -#? -asdf(2) - -asdf = '' - -from a import (b -def blub(): - return 0 -def wrong_indents(): - asdf = 3 - asdf - asdf( - # TODO this seems to be wrong now? - ##? int() - asdf -def openbrace(): - asdf = 3 - asdf( - #? int() - asdf - return 1 - -#? int() -openbrace() - -blub([ -#? int() -openbrace() - -def indentfault(): - asd( - indentback - -#? [] -indentfault(). - -def openbrace2(): - asd( -def normalfunc(): - return 1 - -#? int() -normalfunc() - -# dots in param -def f(seq1...=None): - return seq1 -#? -f(1) - -@ -def test_empty_decorator(): - return 1 - -#? int() -test_empty_decorator() - -def invalid_param(param=): - #? - param -# ----------------- -# flows -# ----------------- - -# first part not complete (raised errors) -if a - a -else: - #? ['AttributeError'] - AttributeError - -try -#? ['AttributeError'] -except AttributeError - pass -finally: - pass - -#? ['isinstance'] -if isi -try: - except TypeError: - #? str() - str() - -def break(): pass -# wrong ternary expression -a = '' -a = 1 if -#? str() -a - -# No completions for for loops without the right syntax -for for_local in : - for_local -#? [] -for_local -#? -for_local - - -# ----------------- -# list comprehensions -# ----------------- - -a2 = [for a2 in [0]] -#? -a2[0] - -a3 = [for xyz in] -#? -a3[0] - -a3 = [a4 for in 'b'] -#? -a3[0] - -a3 = [a4 for a in for x in y] -#? -a3[0] - -a = [for a in -def break(): pass - -#? -a[0] - -a = [a for a in [1,2] -def break(): pass -#? -a[0] - -#? [] -int()).real - -# ----------------- -# keywords -# ----------------- - -#! [] -as - -def empty_assert(): - x = 3 - assert - #? int() - x - -import datetime as - - -# ----------------- -# statements -# ----------------- - -call = '' -invalid = .call -#? -invalid - -invalid = call?.call -#? str() -invalid - -# comma -invalid = ,call -#? str() -invalid - - -# ----------------- -# classes -# ----------------- - -class BrokenPartsOfClass(): - def foo(self): - # This construct contains two places where Jedi with Python 3 can fail. - # It should just ignore those constructs and still execute `bar`. - pass - if 2: - try: - pass - except ValueError, e: - raise TypeError, e - else: - pass - - def bar(self): - self.x = 3 - return '' - -#? str() -BrokenPartsOfClass().bar() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/isinstance.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/isinstance.py deleted file mode 100644 index 15fb9a7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/isinstance.py +++ /dev/null @@ -1,101 +0,0 @@ -if isinstance(i, str): - #? str() - i - -if isinstance(j, (str, int)): - #? str() int() - j - -while isinstance(k, (str, int)): - #? str() int() - k - -if not isinstance(k, (str, int)): - #? - k - -while not isinstance(k, (str, int)): - #? - k - -assert isinstance(ass, int) -#? int() -ass - -assert isinstance(ass, str) -assert not isinstance(ass, int) - -if 2: - #? str() - ass - -# ----------------- -# invalid arguments -# ----------------- - -if isinstance(wrong, str()): - #? - wrong - -# ----------------- -# in functions -# ----------------- - -import datetime - - -def fooooo(obj): - if isinstance(obj, datetime.datetime): - #? datetime.datetime() - obj - - -def fooooo2(obj): - if isinstance(obj, datetime.date): - return obj - else: - return 1 - -a -# In earlier versions of Jedi, this returned both datetime and int, but now -# Jedi does flow checks and realizes that the top return isn't executed. -#? int() -fooooo2('') - - -def isinstance_func(arr): - for value in arr: - if isinstance(value, dict): - # Shouldn't fail, even with the dot. - #? 17 dict() - value. - elif isinstance(value, int): - x = value - #? int() - x - -# ----------------- -# Names with multiple indices. -# ----------------- - -class Test(): - def __init__(self, testing): - if isinstance(testing, str): - self.testing = testing - else: - self.testing = 10 - - def boo(self): - if isinstance(self.testing, str): - # TODO this is wrong, it should only be str. - #? str() int() - self.testing - #? Test() - self - -# ----------------- -# Syntax -# ----------------- - -#? -isinstance(1, int()) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/keywords.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/keywords.py deleted file mode 100644 index 9631e8d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/keywords.py +++ /dev/null @@ -1,59 +0,0 @@ - -#? ['raise'] -raise - -#? ['Exception'] -except - -#? [] -b + continu - -#? [] -b + continue - -#? ['continue'] -b; continue - -#? ['continue'] -b; continu - -#? [] -c + brea - -#? [] -a + break - -#? ['break'] -b; break - -# ----------------- -# Keywords should not appear everywhere. -# ----------------- - -#? [] -with open() as f -#? [] -def i -#? [] -class i - -#? [] -continue i - -# More syntax details, e.g. while only after newline, but not after semicolon, -# continue also after semicolon -#? ['while'] -while -#? [] -x while -#? [] -x; while -#? ['continue'] -x; continue - -#? [] -and -#? ['and'] -x and -#? [] -x * and diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/lambdas.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/lambdas.py deleted file mode 100644 index 524df0c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/lambdas.py +++ /dev/null @@ -1,113 +0,0 @@ -# ----------------- -# lambdas -# ----------------- -a = lambda: 3 -#? int() -a() - -x = [] -a = lambda x: x -#? int() -a(0) - -#? float() -(lambda x: x)(3.0) - -arg_l = lambda x, y: y, x -#? float() -arg_l[0]('', 1.0) -#? list() -arg_l[1] - -arg_l = lambda x, y: (y, x) -args = 1,"" -result = arg_l(*args) -#? tuple() -result -#? str() -result[0] -#? int() -result[1] - -def with_lambda(callable_lambda, *args, **kwargs): - return callable_lambda(1, *args, **kwargs) - -#? int() -with_lambda(arg_l, 1.0)[1] -#? float() -with_lambda(arg_l, 1.0)[0] -#? float() -with_lambda(arg_l, y=1.0)[0] -#? int() -with_lambda(lambda x: x) -#? float() -with_lambda(lambda x, y: y, y=1.0) - -arg_func = lambda *args, **kwargs: (args[0], kwargs['a']) -#? int() -arg_func(1, 2, a='', b=10)[0] -#? list() -arg_func(1, 2, a=[], b=10)[1] - -# magic method -a = lambda: 3 -#? ['__closure__'] -a.__closure__ - -class C(): - def __init__(self, foo=1.0): - self.a = lambda: 1 - self.foo = foo - - def ret(self): - return lambda: self.foo - - def with_param(self): - return lambda x: x + self.a() - - lambd = lambda self: self.foo - -#? int() -C().a() - -#? str() -C('foo').ret()() - -index = C().with_param()(1) -#? float() -['', 1, 1.0][index] - -#? float() -C().lambd() -#? int() -C(1).lambd() - - -def xy(param): - def ret(a, b): - return a + b - - return lambda b: ret(param, b) - -#? int() -xy(1)(2) - -# ----------------- -# lambda param (#379) -# ----------------- -class Test(object): - def __init__(self, pred=lambda a, b: a): - self.a = 1 - #? int() - self.a - #? float() - pred(1.0, 2) - -# ----------------- -# test_nocond in grammar (happens in list comprehensions with `if`) -# ----------------- -# Doesn't need to do anything yet. It should just not raise an error. These -# nocond lambdas make no sense at all. - -#? int() -[a for a in [1,2] if lambda: 3][0] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/named_param.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/named_param.py deleted file mode 100644 index 66ba59e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/named_param.py +++ /dev/null @@ -1,62 +0,0 @@ -""" -Named Params: ->>> def a(abc): pass -... ->>> a(abc=3) # <- this stuff (abc) -""" - -def a(abc): - pass - -#? 5 ['abc'] -a(abc) - - -def a(*some_args, **some_kwargs): - pass - -#? 11 [] -a(some_args) - -#? 13 [] -a(some_kwargs) - -def multiple(foo, bar): - pass - -#? 17 ['bar'] -multiple(foo, bar) - -#? ['bar'] -multiple(foo, bar - -my_lambda = lambda lambda_param: lambda_param + 1 -#? 22 ['lambda_param'] -my_lambda(lambda_param) - -# __call__ / __init__ -class Test(object): - def __init__(self, hello_other): - pass - - def __call__(self, hello): - pass - - def test(self, blub): - pass - -#? 10 ['hello_other'] -Test(hello=) -#? 12 ['hello'] -Test()(hello=) -#? 11 [] -Test()(self=) -#? 16 [] -Test().test(self=) -#? 16 ['blub'] -Test().test(blub=) - -# builtins - -#? 12 [] -any(iterable=) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/on_import.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/on_import.py deleted file mode 100644 index 733d741..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/on_import.py +++ /dev/null @@ -1,110 +0,0 @@ -def from_names(): - #? ['mod1'] - from import_tree.pkg. - #? ['path'] - from os. - -def from_names_goto(): - from import_tree import pkg - #? pkg - from import_tree.pkg - -def builtin_test(): - #? ['math'] - import math - -# ----------------- -# completions within imports -# ----------------- - -#? ['sqlite3'] -import sqlite3 - -#? ['classes'] -import classes - -#? ['timedelta'] -from datetime import timedel -#? 21 [] -from datetime.timedel import timedel - -# should not be possible, because names can only be looked up 1 level deep. -#? [] -from datetime.timedelta import resolution -#? [] -from datetime.timedelta import - -#? ['Cursor'] -from sqlite3 import Cursor - -#? ['some_variable'] -from . import some_variable -#? ['arrays'] -from . import arrays -#? [] -from . import import_tree as ren -#? [] -import json as - -import os -#? os.path.join -from os.path import join - -# ----------------- -# special positions -> edge cases -# ----------------- -import datetime - -#? 6 datetime -from datetime.time import time - -#? [] -import datetime. -#? [] -import datetime.date - -#? 21 ['import'] -from import_tree.pkg import pkg -#? 49 ['a', 'foobar', '__name__', '__doc__', '__file__', '__package__'] -from import_tree.pkg.mod1 import not_existant, # whitespace before -#? ['a', 'foobar', '__name__', '__doc__', '__file__', '__package__'] -from import_tree.pkg.mod1 import not_existant, -#? 22 ['mod1'] -from import_tree.pkg. import mod1 -#? 17 ['mod1', 'mod2', 'random', 'pkg', 'rename1', 'rename2', 'classes', 'recurse_class1', 'recurse_class2', 'invisible_pkg', 'flow_import'] -from import_tree. import pkg - -#? 18 ['pkg'] -from import_tree.p import pkg - -#? 17 ['import_tree'] -from .import_tree import -#? 10 ['run'] -from ..run import -#? ['run'] -from ..run -#? 10 ['run'] -from ..run. -#? [] -from ..run. - -#? ['run'] -from .. import run - -#? [] -from not_a_module import - - -#137 -import json -#? 23 json.dump -from json import load, dump -#? 17 json.load -from json import load, dump -# without the from clause: -import json, datetime -#? 7 json -import json, datetime -#? 13 datetime -import json, datetime - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/ordering.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/ordering.py deleted file mode 100644 index 61eb192..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/ordering.py +++ /dev/null @@ -1,195 +0,0 @@ -# ----------------- -# normal -# ----------------- -a = "" -a = 1 - -#? int() -a -#? [] -a.append - -a = list - -b = 1; b = "" -#? str() -b - -# temp should not be accessible before definition -#? [] -temp - -a = 1 -temp = b; -b = a -a = temp -#? int() -b -#? int() -b -#? str() -a - -a = tuple -if 1: - a = list - -#? ['append'] -a.append -#? ['index'] -a.index - -# ----------------- -# tuples exchanges -# ----------------- -a, b = 1, "" -#? int() -a -#? str() -b - -b, a = a, b -#? int() -b -#? str() -a - -b, a = a, b -#? int() -a -#? str() -b - -# ----------------- -# function -# ----------------- -def a(a=3): - #? int() - a - #? [] - a.func - return a - -#? int() -a(2) -#? [] -a(2).func - -a_param = 3 -def func(a_param): - # should not be int - #? [] - a_param. - -from os import path - - -# should not return a function, because `a` is a function above -def f(b, a): return a -#? [] -f(b=3). - -# ----------------- -# closure -# ----------------- - -def x(): - a = 0 - - def x(): - return a - - a = 3.0 - return x() - -#? float() -x() - -# ----------------- -# class -# ----------------- -class A(object): - a = "" - a = 3 - #? int() - a - a = list() - def __init__(self): - self.b = "" - - def before(self): - self.b = 3 - # TODO should this be so? include entries after cursor? - #? int() str() list - self.b - self.b = list - - self.a = 1 - #? str() int() - self.a - - #? ['after'] - self.after - - self.c = 3 - #? int() - self.c - - def after(self): - self.a = '' - - c = set() - -#? list() -A.a - -a = A() -#? ['after'] -a.after -#? [] -a.upper -#? [] -a.append -#? [] -a.real - -#? str() int() -a.a - -a = 3 -class a(): - def __init__(self, a): - self.a = a - -#? float() -a(1.0).a -#? -a().a - -# ----------------- -# imports -# ----------------- - -math = 3 -import math -#? ['cosh'] -math.cosh -#? [] -math.real - -math = 3 -#? int() -math -#? [] -math.cos - -# do the same for star imports -cosh = 3 -from math import * -# cosh doesn't work, but that's not a problem, star imports should be at the -# start of EVERY script! -cosh.real - -cosh = 3 -#? int() -cosh diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/parser.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/parser.py deleted file mode 100644 index 68793f4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/parser.py +++ /dev/null @@ -1,43 +0,0 @@ -""" -Issues with the parser and not the type inference should be part of this file. -""" - -class IndentIssues(): - """ - issue jedi-vim#288 - Which is really a fast parser issue. It used to start a new block at the - parentheses, because it had problems with the indentation. - """ - def one_param( - self, - ): - return 1 - - def with_param( - self, - y): - return y - - - -#? int() -IndentIssues().one_param() - -#? str() -IndentIssues().with_param('') - - -""" -Just because there's a def keyword, doesn't mean it should not be able to -complete to definition. -""" -definition = 0 -#? ['definition'] -str(def - - -# It might be hard to determine the context -class Foo(object): - @property - #? ['str'] - def bar(str diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_basic.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_basic.py deleted file mode 100644 index 0230d37..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_basic.py +++ /dev/null @@ -1,167 +0,0 @@ -""" Pep-0484 type hinting """ - -# python >= 3.2 - - -class A(): - pass - - -def function_parameters(a: A, b, c: str, d: int, e: str, f: str, g: int=4): - """ - :param e: if docstring and annotation agree, only one should be returned - :type e: str - :param f: if docstring and annotation disagree, both should be returned - :type f: int - """ - #? A() - a - #? - b - #? str() - c - #? int() - d - #? str() - e - #? int() str() - f - # int() - g - - -def return_unspecified(): - pass - -#? -return_unspecified() - - -def return_none() -> None: - """ - Return type None means the same as no return type as far as jedi - is concerned - """ - pass - -#? -return_none() - - -def return_str() -> str: - pass - -#? str() -return_str() - - -def return_custom_class() -> A: - pass - -#? A() -return_custom_class() - - -def return_annotation_and_docstring() -> str: - """ - :rtype: int - """ - pass - -#? str() int() -return_annotation_and_docstring() - - -def return_annotation_and_docstring_different() -> str: - """ - :rtype: str - """ - pass - -#? str() -return_annotation_and_docstring_different() - - -def annotation_forward_reference(b: "B") -> "B": - #? B() - b - -#? ["test_element"] -annotation_forward_reference(1).t - -class B: - test_element = 1 - pass - -#? B() -annotation_forward_reference(1) - - -class SelfReference: - test_element = 1 - def test_method(self, x: "SelfReference") -> "SelfReference": - #? SelfReference() - x - #? ["test_element", "test_method"] - self.t - #? ["test_element", "test_method"] - x.t - #? ["test_element", "test_method"] - self.test_method(1).t - -#? SelfReference() -SelfReference().test_method() - -def function_with_non_pep_0484_annotation( - x: "I can put anything here", - xx: "", - yy: "\r\n\0;+*&^564835(---^&*34", - y: 3 + 3, - zz: float) -> int("42"): - # infers int from function call - #? int() - x - # infers int from function call - #? int() - xx - # infers int from function call - #? int() - yy - # infers str from function call - #? str() - y - #? float() - zz -#? -function_with_non_pep_0484_annotation(1, 2, 3, "force string") - -def function_forward_reference_dynamic( - x: return_str_type(), - y: "return_str_type()") -> None: - #? - x - #? str() - y - -def return_str_type(): - return str - - -X = str -def function_with_assined_class_in_reference(x: X, y: "Y"): - #? str() - x - #? int() - y -Y = int - -def just_because_we_can(x: "flo" + "at"): - #? float() - x - - -def keyword_only(a: str, *, b: str): - #? ['startswith'] - a.startswi - #? ['startswith'] - b.startswi diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_comments.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_comments.py deleted file mode 100644 index 7d5f7c2..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_comments.py +++ /dev/null @@ -1,109 +0,0 @@ -a = 3 # type: str -#? str() -a - -b = 3 # type: str but I write more -#? int() -b - -c = 3 # type: str # I comment more -#? str() -c - -d = "It should not read comments from the next line" -# type: int -#? str() -d - -# type: int -e = "It should not read comments from the previous line" -#? str() -e - -class BB: pass - -def test(a, b): - a = a # type: BB - c = a # type: str - d = a - # type: str - e = a # type: str # Should ignore long whitespace - - #? BB() - a - #? str() - c - #? BB() - d - #? str() - e - -a,b = 1, 2 # type: str, float -#? str() -a -#? float() -b - -class Employee: - pass - -# The typing library is not installable for Python 2.6, therefore ignore the -# following tests. -# python >= 2.7 - -from typing import List -x = [] # type: List[Employee] -#? Employee() -x[1] -x, y, z = [], [], [] # type: List[int], List[int], List[str] -#? int() -y[2] -x, y, z = [], [], [] # type: (List[float], List[float], List[BB]) -for zi in z: - #? BB() - zi - -x = [ - 1, - 2, -] # type: List[str] - -#? str() -x[1] - - -for bar in foo(): # type: str - #? str() - bar - -for bar, baz in foo(): # type: int, float - #? int() - bar - #? float() - baz - -for bar, baz in foo(): - # type: str, str - """ type hinting on next line should not work """ - #? - bar - #? - baz - -with foo(): # type: int - ... - -with foo() as f: # type: str - #? str() - f - -with foo() as f: - # type: str - """ type hinting on next line should not work """ - #? - f - -aaa = some_extremely_long_function_name_that_doesnt_leave_room_for_hints() \ - # type: float # We should be able to put hints on the next line with a \ -#? float() -aaa diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_typing.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_typing.py deleted file mode 100644 index 75c1c0b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0484_typing.py +++ /dev/null @@ -1,263 +0,0 @@ -""" -Test the typing library, with docstrings. This is needed since annotations -are not supported in python 2.7 else then annotating by comment (and this is -still TODO at 2016-01-23) -""" -# There's no Python 2.6 typing module. -# python >= 2.7 -import typing -class B: - pass - -def we_can_has_sequence(p, q, r, s, t, u): - """ - :type p: typing.Sequence[int] - :type q: typing.Sequence[B] - :type r: typing.Sequence[int] - :type s: typing.Sequence["int"] - :type t: typing.MutableSequence[dict] - :type u: typing.List[float] - """ - #? ["count"] - p.c - #? int() - p[1] - #? ["count"] - q.c - #? B() - q[1] - #? ["count"] - r.c - #? int() - r[1] - #? ["count"] - s.c - #? int() - s[1] - #? [] - s.a - #? ["append"] - t.a - #? dict() - t[1] - #? ["append"] - u.a - #? float() - u[1] - -def iterators(ps, qs, rs, ts): - """ - :type ps: typing.Iterable[int] - :type qs: typing.Iterator[str] - :type rs: typing.Sequence["ForwardReference"] - :type ts: typing.AbstractSet["float"] - """ - for p in ps: - #? int() - p - #? - next(ps) - a, b = ps - #? int() - a - ##? int() --- TODO fix support for tuple assignment - # https://github.com/davidhalter/jedi/pull/663#issuecomment-172317854 - # test below is just to make sure that in case it gets fixed by accident - # these tests will be fixed as well the way they should be - #? - b - - for q in qs: - #? str() - q - #? str() - next(qs) - for r in rs: - #? ForwardReference() - r - #? - next(rs) - for t in ts: - #? float() - t - -def sets(p, q): - """ - :type p: typing.AbstractSet[int] - :type q: typing.MutableSet[float] - """ - #? [] - p.a - #? ["add"] - q.a - -def tuple(p, q, r): - """ - :type p: typing.Tuple[int] - :type q: typing.Tuple[int, str, float] - :type r: typing.Tuple[B, ...] - """ - #? int() - p[0] - #? int() - q[0] - #? str() - q[1] - #? float() - q[2] - #? B() - r[0] - #? B() - r[1] - #? B() - r[2] - #? B() - r[10000] - i, s, f = q - #? int() - i - ##? str() --- TODO fix support for tuple assignment - # https://github.com/davidhalter/jedi/pull/663#issuecomment-172317854 - #? - s - ##? float() --- TODO fix support for tuple assignment - # https://github.com/davidhalter/jedi/pull/663#issuecomment-172317854 - #? - f - -class Key: - pass - -class Value: - pass - -def mapping(p, q, d, r, s, t): - """ - :type p: typing.Mapping[Key, Value] - :type q: typing.MutableMapping[Key, Value] - :type d: typing.Dict[Key, Value] - :type r: typing.KeysView[Key] - :type s: typing.ValuesView[Value] - :type t: typing.ItemsView[Key, Value] - """ - #? [] - p.setd - #? ["setdefault"] - q.setd - #? ["setdefault"] - d.setd - #? Value() - p[1] - for key in p: - #? Key() - key - for key in p.keys(): - #? Key() - key - for value in p.values(): - #? Value() - value - for item in p.items(): - #? Key() - item[0] - #? Value() - item[1] - (key, value) = item - #? Key() - key - #? Value() - value - for key, value in p.items(): - #? Key() - key - #? Value() - value - for key in r: - #? Key() - key - for value in s: - #? Value() - value - for key, value in t: - #? Key() - key - #? Value() - value - -def union(p, q, r, s, t): - """ - :type p: typing.Union[int] - :type q: typing.Union[int, int] - :type r: typing.Union[int, str, "int"] - :type s: typing.Union[int, typing.Union[str, "typing.Union['float', 'dict']"]] - :type t: typing.Union[int, None] - """ - #? int() - p - #? int() - q - #? int() str() - r - #? int() str() float() dict() - s - #? int() - t - -def optional(p): - """ - :type p: typing.Optional[int] - Optional does not do anything special. However it should be recognised - as being of that type. Jedi doesn't do anything with the extra into that - it can be None as well - """ - #? int() - p - -class ForwardReference: - pass - -class TestDict(typing.Dict[str, int]): - def setdud(self): - pass - -def testdict(x): - """ - :type x: TestDict - """ - #? ["setdud", "setdefault"] - x.setd - for key in x.keys(): - #? str() - key - for value in x.values(): - #? int() - value - -x = TestDict() -#? ["setdud", "setdefault"] -x.setd -for key in x.keys(): - #? str() - key -for value in x.values(): - #? int() - value -# python >= 3.2 -""" -docstrings have some auto-import, annotations can use all of Python's -import logic -""" -import typing as t -def union2(x: t.Union[int, str]): - #? int() str() - x - -from typing import Union -def union3(x: Union[int, str]): - #? int() str() - x - -from typing import Union as U -def union4(x: U[int, str]): - #? int() str() - x diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0526_variables.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0526_variables.py deleted file mode 100644 index 24b681d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/pep0526_variables.py +++ /dev/null @@ -1,22 +0,0 @@ -""" -PEP 526 introduced a new way of using type annotations on variables. It was -introduced in Python 3.6. -""" -# python >= 3.6 - -import typing - -asdf = '' -asdf: int -# This is not necessarily correct, but for now this is ok (at least no error). -#? int() -asdf - - -direct: int = NOT_DEFINED -#? int() -direct - -with_typing_module: typing.List[float] = NOT_DEFINED -#? float() -with_typing_module[0] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/precedence.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/precedence.py deleted file mode 100644 index 6078115..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/precedence.py +++ /dev/null @@ -1,138 +0,0 @@ -""" -Test Jedi's operation understanding. Jedi should understand simple additions, -multiplications, etc. -""" -# ----------------- -# numbers -# ----------------- -x = [1, 'a', 1.0] - -#? int() str() float() -x[12] - -#? float() -x[1 + 1] - -index = 0 + 1 - -#? str() -x[index] - -#? int() -x[1 + (-1)] - -def calculate(number): - return number + constant - -constant = 1 - -#? float() -x[calculate(1)] - -def calculate(number): - return number + constant - -# ----------------- -# strings -# ----------------- - -x = 'upp' + 'e' - -#? str.upper -getattr(str, x + 'r') - -a = "a"*3 -#? str() -a -a = 3 * "a" -#? str() -a - -a = 3 * "a" -#? str() -a - -#? int() -(3 ** 3) -#? int() str() -(3 ** 'a') - -# ----------------- -# assignments -# ----------------- - -x = [1, 'a', 1.0] - -i = 0 -i += 1 -i += 1 -#? float() -x[i] - -i = 1 -i += 1 -i -= 3 -i += 1 -#? int() -x[i] - -# ----------------- -# in -# ----------------- - -if 'X' in 'Y': - a = 3 -else: - a = '' -# For now don't really check for truth values. So in should return both -# results. -#? str() int() -a - -# ----------------- -# for flow assignments -# ----------------- - -class FooBar(object): - fuu = 0.1 - raboof = 'fourtytwo' - -# targets should be working -target = '' -for char in ['f', 'u', 'u']: - target += char -#? float() -getattr(FooBar, target) - -# github #24 -target = u'' -for char in reversed(['f', 'o', 'o', 'b', 'a', 'r']): - target += char - -#? str() -getattr(FooBar, target) - - -# ----------------- -# repetition problems -> could be very slow and memory expensive - shouldn't -# be. -# ----------------- - -b = [str(1)] -l = list -for x in [l(0), l(1), l(2), l(3), l(4), l(5), l(6), l(7), l(8), l(9), l(10), - l(11), l(12), l(13), l(14), l(15), l(16), l(17), l(18), l(19), l(20), - l(21), l(22), l(23), l(24), l(25), l(26), l(27), l(28), l(29)]: - b += x - -#? str() -b[1] - - -# ----------------- -# undefined names -# ----------------- -a = foobarbaz + 'hello' - -#? int() float() -{'hello': 1, 'bar': 1.0}[a] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/recursion.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/recursion.py deleted file mode 100644 index a3e7670..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/recursion.py +++ /dev/null @@ -1,78 +0,0 @@ -""" -Code that might cause recursion issues (or has caused in the past). -""" - -def Recursion(): - def recurse(self): - self.a = self.a - self.b = self.b.recurse() - -#? -Recursion().a - -#? -Recursion().b - - -class X(): - def __init__(self): - self.recursive = [1, 3] - - def annoying(self): - self.recursive = [self.recursive[0]] - - def recurse(self): - self.recursive = [self.recursive[1]] - -#? int() -X().recursive[0] - - -def to_list(iterable): - return list(set(iterable)) - - -def recursion1(foo): - return to_list(to_list(foo)) + recursion1(foo) - -#? int() -recursion1([1,2])[0] - - -class FooListComp(): - def __init__(self): - self.recursive = [1] - - def annoying(self): - self.recursive = [x for x in self.recursive] - - -#? int() -FooListComp().recursive[0] - - -class InstanceAttributeIfs: - def b(self): - self.a1 = 1 - self.a2 = 1 - - def c(self): - self.a2 = '' - - def x(self): - self.b() - - if self.a1 == 1: - self.a1 = self.a1 + 1 - if self.a2 == UNDEFINED: - self.a2 = self.a2 + 1 - - #? int() - self.a1 - #? int() str() - self.a2 - -#? int() -InstanceAttributeIfs().a1 -#? int() str() -InstanceAttributeIfs().a2 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/stdlib.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/stdlib.py deleted file mode 100644 index b6b739a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/stdlib.py +++ /dev/null @@ -1,249 +0,0 @@ -""" -std library stuff -""" - -# ----------------- -# builtins -# ----------------- -arr = [''] - -#? str() -sorted(arr)[0] - -#? str() -next(reversed(arr)) -next(reversed(arr)) - -# should not fail if there's no return value. -def yielder(): - yield None - -#? None -next(reversed(yielder())) - -# empty reversed should not raise an error -#? -next(reversed()) - -#? str() -next(open('')) - -#? int() -{'a':2}.setdefault('a', 3) - -# Compiled classes should have the meta class attributes. -#? ['__itemsize__'] -tuple.__itemsize__ - -# ----------------- -# type() calls with one parameter -# ----------------- -#? int -type(1) -#? int -type(int()) -#? type -type(int) -#? type -type(type) -#? list -type([]) - -def x(): - yield 1 -generator = type(x()) -#? generator -type(x for x in []) -#? type(x) -type(lambda: x) - -import math -import os -#? type(os) -type(math) -class X(): pass -#? type -type(X) - - -with open('foo') as f: - for line in f.readlines(): - #? str() - line -# ----------------- -# enumerate -# ----------------- -for i, j in enumerate(["as", "ad"]): - #? int() - i - #? str() - j - -# ----------------- -# re -# ----------------- -import re -c = re.compile(r'a') -# re.compile should not return str -> issue #68 -#? [] -c.startswith -#? int() -c.match().start() - -#? int() -re.match(r'a', 'a').start() - -for a in re.finditer('a', 'a'): - #? int() - a.start() - -#? str() -re.sub('a', 'a') - -# ----------------- -# ref -# ----------------- -import weakref - -#? int() -weakref.proxy(1) - -#? weakref.ref() -weakref.ref(1) -#? int() -weakref.ref(1)() - -# ----------------- -# functools -# ----------------- -import functools - -basetwo = functools.partial(int, base=2) -#? int() -basetwo() - -def function(a, b): - return a, b -a = functools.partial(function, 0) - -#? int() -a('')[0] -#? str() -a('')[1] - -kw = functools.partial(function, b=1.0) -tup = kw(1) -#? int() -tup[0] -#? float() -tup[1] - -def my_decorator(f): - @functools.wraps(f) - def wrapper(*args, **kwds): - return f(*args, **kwds) - return wrapper - -@my_decorator -def example(a): - return a - -#? str() -example('') - - -# ----------------- -# sqlite3 (#84) -# ----------------- - -import sqlite3 -#? sqlite3.Connection() -con = sqlite3.connect() -#? sqlite3.Cursor() -c = con.cursor() -#? sqlite3.Row() -row = c.fetchall()[0] -#? str() -row.keys()[0] - -def huhu(db): - """ - :type db: sqlite3.Connection - :param db: the db connection - """ - #? sqlite3.Connection() - db - -# ----------------- -# hashlib -# ----------------- - -import hashlib - -#? ['md5'] -hashlib.md5 - -# ----------------- -# copy -# ----------------- - -import copy -#? int() -copy.deepcopy(1) - -#? -copy.copy() - -# ----------------- -# json -# ----------------- - -# We don't want any results for json, because it depends on IO. -import json -#? -json.load('asdf') -#? -json.loads('[1]') - -# ----------------- -# random -# ----------------- - -import random -class A(object): - def say(self): pass -class B(object): - def shout(self): pass -cls = random.choice([A, B]) -#? ['say', 'shout'] -cls().s - -# ----------------- -# random -# ----------------- - -import zipfile -z = zipfile.ZipFile("foo") -# It's too slow. So we don't run it at the moment. -##? ['upper'] -z.read('name').upper - -# ----------------- -# contextlib -# ----------------- - -import contextlib -with contextlib.closing('asd') as string: - #? str() - string - -# ----------------- -# shlex -# ----------------- - -# Github issue #929 -import shlex -qsplit = shlex.split("foo, ferwerwerw werw werw e") -for part in qsplit: - #? str() None - part diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/sys_path.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/sys_path.py deleted file mode 100644 index 890f2fe..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/sys_path.py +++ /dev/null @@ -1,24 +0,0 @@ - -import sys -import os -from os import dirname - -sys.path.insert(0, '../../jedi') -sys.path.append(dirname(os.path.abspath('thirdparty' + os.path.sep + 'asdf'))) - -# modifications, that should fail: -# syntax err -sys.path.append('a' +* '/thirdparty') - -#? ['evaluate'] -import evaluate - -#? ['evaluator_function_cache'] -evaluate.Evaluator_fu - -# Those don't work because dirname and abspath are not properly understood. -##? ['jedi_'] -import jedi_ - -##? ['el'] -jedi_.el diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/PyQt4_.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/PyQt4_.py deleted file mode 100644 index f4e4183..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/PyQt4_.py +++ /dev/null @@ -1,19 +0,0 @@ -from PyQt4.QtCore import * -from PyQt4.QtGui import * - -#? ['QActionGroup'] -QActionGroup - -#? ['currentText'] -QStyleOptionComboBox().currentText - -#? [] -QStyleOptionComboBox().currentText. - -from PyQt4 import QtGui - -#? ['currentText'] -QtGui.QStyleOptionComboBox().currentText - -#? [] -QtGui.QStyleOptionComboBox().currentText. diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/django_.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/django_.py deleted file mode 100644 index 9914a6d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/django_.py +++ /dev/null @@ -1,11 +0,0 @@ -#! ['class ObjectDoesNotExist'] -from django.core.exceptions import ObjectDoesNotExist -import django - -#? ['get_version'] -django.get_version - -from django.conf import settings - -#? ['configured'] -settings.configured diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/jedi_.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/jedi_.py deleted file mode 100644 index dc384b1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/jedi_.py +++ /dev/null @@ -1,52 +0,0 @@ - -from jedi import functions, evaluate, parsing - -el = functions.completions()[0] -#? ['description'] -el.description - -#? str() -el.description - - -scopes, path, dot, like = \ - api._prepare_goto(source, row, column, path, True) - -# has problems with that (sometimes) very deep nesting. -#? set() -el = scopes - -# get_names_for_scope is also recursion stuff -#? tuple() -el = list(evaluate.get_names_for_scope())[0] - -#? int() parsing.Module() -el = list(evaluate.get_names_for_scope(1))[0][0] -#? parsing.Module() -el = list(evaluate.get_names_for_scope())[0][0] - -#? list() -el = list(evaluate.get_names_for_scope(1))[0][1] -#? list() -el = list(evaluate.get_names_for_scope())[0][1] - -#? list() -parsing.Scope((0,0)).get_set_vars() -#? parsing.Import() parsing.Name() -parsing.Scope((0,0)).get_set_vars()[0] -# TODO access parent is not possible, because that is not set in the class -## parsing.Class() -parsing.Scope((0,0)).get_set_vars()[0].parent - -#? parsing.Import() parsing.Name() -el = list(evaluate.get_names_for_scope())[0][1][0] - -#? evaluate.Array() evaluate.Class() evaluate.Function() evaluate.Instance() -list(evaluate.follow_call())[0] - -# With the right recursion settings, this should be possible (and maybe more): -# Array Class Function Generator Instance Module -# However, this was produced with the recursion settings 10/350/10000, and -# lasted 18.5 seconds. So we just have to be content with the results. -#? evaluate.Class() evaluate.Function() -evaluate.get_scopes_for_name()[0] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/psycopg2_.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/psycopg2_.py deleted file mode 100644 index 834704b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/psycopg2_.py +++ /dev/null @@ -1,11 +0,0 @@ -import psycopg2 - -conn = psycopg2.connect('dbname=test') - -#? ['cursor'] -conn.cursor - -cur = conn.cursor() - -#? ['fetchall'] -cur.fetchall diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/pylab_.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/pylab_.py deleted file mode 100644 index ab132a4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/thirdparty/pylab_.py +++ /dev/null @@ -1,36 +0,0 @@ -import pylab - -# two gotos -#! ['module numpy'] -import numpy - -#! ['module random'] -import numpy.random - -#? ['array2string'] -numpy.array2string - -#? ['shape'] -numpy.matrix().shape - -#? ['random_integers'] -pylab.random_integers - -#? [] -numpy.random_integers - -#? ['random_integers'] -numpy.random.random_integers -#? ['sample'] -numpy.random.sample - -import numpy -na = numpy.array([1,2]) -#? ['shape'] -na.shape - -# shouldn't raise an error #29, jedi-vim -# doesn't return something, because matplotlib uses __import__ -fig = pylab.figure() -#? -fig.add_subplot diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/types.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/types.py deleted file mode 100644 index 2ef01f9..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/types.py +++ /dev/null @@ -1,129 +0,0 @@ -# ----------------- -# non array -# ----------------- - -#? ['imag'] -int.imag - -#? [] -int.is_integer - -#? ['is_integer'] -float.is_int - -#? ['is_integer'] -1.0.is_integer - -#? ['upper'] -"".upper - -#? ['upper'] -r"".upper - -# strangely this didn't work, because the = is used for assignments -#? ['upper'] -"=".upper -a = "=" -#? ['upper'] -a.upper - - -# ----------------- -# lists -# ----------------- -arr = [] -#? ['append'] -arr.app - -#? ['append'] -list().app -#? ['append'] -[].append - -arr2 = [1,2,3] -#? ['append'] -arr2.app - -#? int() -arr.count(1) - -x = [] -#? -x.pop() -x = [3] -#? int() -x.pop() -x = [] -x.append(1.0) -#? float() -x.pop() - -# ----------------- -# dicts -# ----------------- -dic = {} - -#? ['copy', 'clear'] -dic.c - -dic2 = dict(a=1, b=2) -#? ['pop', 'popitem'] -dic2.p -#? ['popitem'] -{}.popitem - -dic2 = {'asdf': 3} -#? ['popitem'] -dic2.popitem - -#? int() -dic2['asdf'] - -d = {'a': 3, 1.0: list} - -#? int() list -d.values()[0] -##? int() list -dict(d).values()[0] - -#? str() -d.items()[0][0] -#? int() -d.items()[0][1] - -# ----------------- -# tuples -# ----------------- -tup = ('',2) - -#? ['count'] -tup.c - -tup2 = tuple() -#? ['index'] -tup2.i -#? ['index'] -().i - -tup3 = 1,"" -#? ['index'] -tup3.index - -tup4 = 1,"" -#? ['index'] -tup4.index - -# ----------------- -# set -# ----------------- -# Set literals are not valid in 2.6. -# python >= 2.7 -set_t = {1,2} - -#? ['clear', 'copy'] -set_t.c - -set_t2 = set() - -#? ['clear', 'copy'] -set_t2.c diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/usages.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/usages.py deleted file mode 100644 index d7231b1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/completion/usages.py +++ /dev/null @@ -1,316 +0,0 @@ -""" -Renaming tests. This means search for usages. -I always leave a little bit of space to add room for additions, because the -results always contain position informations. -""" -#< 4 (0,4), (3,0), (5,0), (17,0), (12,4), (14,5), (15,0) -def abc(): pass - -#< 0 (-3,4), (0,0), (2,0), (14,0), (9,4), (11,5), (12,0) -abc.d.a.bsaasd.abc.d - -abc -# unicode chars shouldn't be a problem. -x['smörbröd'].abc - -# With the new parser these statements are not recognized as stateents, because -# they are not valid Python. -if 1: - abc = -else: - (abc) = -abc = -#< (-17,4), (-14,0), (-12,0), (0,0), (-2,0), (-3,5), (-5,4) -abc - -abc = 5 - - -Abc = 3 - -#< 6 (0,6), (2,4), (5,8), (17,0) -class Abc(): - #< (-2,6), (0,4), (3,8), (15,0) - Abc - - def Abc(self): - Abc; self.c = 3 - - #< 17 (0,16), (2,8) - def a(self, Abc): - #< 10 (-2,16), (0,8) - Abc - - #< 19 (0,18), (2,8) - def self_test(self): - #< 12 (-2,18), (0,8) - self.b - -Abc.d.Abc - - -#< 4 (0,4), (5,1) -def blubi(): - pass - - -#< (-5,4), (0,1) -@blubi -def a(): pass - - -#< 0 (0,0), (1,0) -set_object_var = object() -set_object_var.var = 1 - - -response = 5 -#< 0 (0,0), (1,0), (2,0), (4,0) -response = HttpResponse(mimetype='application/pdf') -response['Content-Disposition'] = 'attachment; filename=%s.pdf' % id -response.write(pdf) -#< (-4,0), (-3,0), (-2,0), (0,0) -response - - -# ----------------- -# imports -# ----------------- -#< (0,7), (3,0) -import module_not_exists - -#< (-3,7), (0,0) -module_not_exists - - -#< ('rename1', 1,0), (0,24), (3,0), (6,17), ('rename2', 4,5), (11,17), (14,17), ('imports', 72, 16) -from import_tree import rename1 - -#< (0,8), ('rename1',3,0), ('rename2',4,20), ('rename2',6,0), (3,32), (8,32), (5,0) -rename1.abc - -#< (-3,8), ('rename1', 3,0), ('rename2', 4,20), ('rename2', 6,0), (0,32), (5,32), (2,0) -from import_tree.rename1 import abc -#< (-5,8), (-2,32), ('rename1', 3,0), ('rename2', 4,20), ('rename2', 6,0), (0,0), (3,32) -abc - -#< 20 ('rename1', 1,0), ('rename2', 4,5), (-11,24), (-8,0), (-5,17), (0,17), (3,17), ('imports', 72, 16) -from import_tree.rename1 import abc - -#< (0, 32), -from import_tree.rename1 import not_existing - -# Shouldn't raise an error or do anything weird. -from not_existing import * - -# ----------------- -# classes -# ----------------- - -class TestMethods(object): - #< 8 (0,8), (2,13) - def a_method(self): - #< 13 (-2,8), (0,13) - self.a_method() - #< 13 (2,8), (0,13), (3,13) - self.b_method() - - def b_method(self): - self.b_method - - -class TestClassVar(object): - #< 4 (0,4), (5,13), (7,21) - class_v = 1 - def a(self): - class_v = 1 - - #< (-5,4), (0,13), (2,21) - self.class_v - #< (-7,4), (-2,13), (0,21) - TestClassVar.class_v - #< (0,8), (-7, 8) - class_v - -class TestInstanceVar(): - def a(self): - #< 13 (4,13), (0,13) - self._instance_var = 3 - - def b(self): - #< (-4,13), (0,13) - self._instance_var - # A call to self used to trigger an error, because it's also a trailer - # with two children. - self() - - -class NestedClass(): - def __getattr__(self, name): - return self - -# Shouldn't find a definition, because there's other `instance`. -# TODO reenable that test -##< (0, 14), -NestedClass().instance - - -# ----------------- -# inheritance -# ----------------- -class Super(object): - #< 4 (0,4), (23,18), (25,13) - base_class = 1 - #< 4 (0,4), - class_var = 1 - - #< 8 (0,8), - def base_method(self): - #< 13 (0,13), (20,13) - self.base_var = 1 - #< 13 (0,13), - self.instance_var = 1 - - #< 8 (0,8), - def just_a_method(self): pass - - -#< 20 (0,16), (-18,6) -class TestClass(Super): - #< 4 (0,4), - class_var = 1 - - def x_method(self): - - #< (0,18), (2,13), (-23,4) - TestClass.base_class - #< (-2,18), (0,13), (-25,4) - self.base_class - #< (-20,13), (0,13) - self.base_var - #< (0, 18), - TestClass.base_var - - - #< 13 (5,13), (0,13) - self.instance_var = 3 - - #< 9 (0,8), - def just_a_method(self): - #< (-5,13), (0,13) - self.instance_var - - -# ----------------- -# properties -# ----------------- -class TestProperty: - - @property - #< 10 (0,8), (5,13) - def prop(self): - return 1 - - def a(self): - #< 13 (-5,8), (0,13) - self.prop - - @property - #< 13 (0,8), (4,5) - def rw_prop(self): - return self._rw_prop - - #< 8 (-4,8), (0,5) - @rw_prop.setter - #< 8 (0,8), (5,13) - def rw_prop(self, value): - self._rw_prop = value - - def b(self): - #< 13 (-5,8), (0,13) - self.rw_prop - -# ----------------- -# *args, **kwargs -# ----------------- -#< 11 (1,11), (0,8) -def f(**kwargs): - return kwargs - - -# ----------------- -# No result -# ----------------- -if isinstance(j, int): - #< (0, 4), - j - -# ----------------- -# Dynamic Param Search -# ----------------- - -class DynamicParam(): - def foo(self): - return - -def check(instance): - #< 13 (-5,8), (0,13) - instance.foo() - -check(DynamicParam()) - -# ----------------- -# Compiled Objects -# ----------------- - -import _sre - -#< 0 (-3,7), (0,0), ('_sre', None, None) -_sre - -# ----------------- -# on syntax -# ----------------- - -#< 0 -import undefined - -# ----------------- -# comprehensions -# ----------------- - -#< 0 (0,0), (2,12) -x = 32 -#< 12 (-2,0), (0,12) -[x for x in x] - -#< 0 (0,0), (2,1), (2,12) -x = 32 -#< 12 (-2,0), (0,1), (0,12) -[x for b in x] - - -#< 1 (0,1), (0,7) -[x for x in something] -#< 7 (0,1), (0,7) -[x for x in something] - -x = 3 -# Not supported syntax in Python 2.6. -# python >= 2.7 -#< 1 (0,1), (0,10) -{x:1 for x in something} -#< 10 (0,1), (0,10) -{x:1 for x in something} - -def x(): - zzz = 3 - if UNDEFINED: - zzz = 5 - if UNDEFINED2: - #< (3, 8), (4, 4), (0, 12), (-3, 8), (-5, 4) - zzz - else: - #< (0, 8), (1, 4), (-3, 12), (-6, 8), (-8, 4) - zzz - zzz diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/__init__.py deleted file mode 100644 index d2ae403..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -""" -An import tree, for testing usages. -""" - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/a.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/a.py deleted file mode 100644 index acc8183..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/a.py +++ /dev/null @@ -1,4 +0,0 @@ -from . import b - -def foo(): - b.bar() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/b.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/b.py deleted file mode 100644 index 4371a5a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/import_tree_for_usages/b.py +++ /dev/null @@ -1,2 +0,0 @@ -def bar(): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/__init__.py deleted file mode 100644 index 3a03a82..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -from simple_import import module - - -def in_function(): - from simple_import import module2 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/module.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/module.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/module2.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/simple_import/module2.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_analysis.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_analysis.py deleted file mode 100644 index cfcd405..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_analysis.py +++ /dev/null @@ -1,12 +0,0 @@ -""" -Test of keywords and ``jedi.keywords`` -""" -from jedi import Script - - -def test_issue436(): - code = "bar = 0\nbar += 'foo' + 4" - errors = set(repr(e) for e in Script(code)._analysis()) - assert len(errors) == 2 - assert '' in errors - assert '' in errors diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_api.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_api.py deleted file mode 100644 index a8064d7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_api.py +++ /dev/null @@ -1,224 +0,0 @@ -""" -Test all things related to the ``jedi.api`` module. -""" - -import os -from textwrap import dedent - -from jedi import api -from jedi._compatibility import is_py3 -from pytest import raises -from parso import cache - - -def test_preload_modules(): - def check_loaded(*modules): - # +1 for None module (currently used) - grammar_cache = next(iter(cache.parser_cache.values())) - assert len(grammar_cache) == len(modules) + 1 - for i in modules: - assert [i in k for k in grammar_cache.keys() if k is not None] - - old_cache = cache.parser_cache.copy() - cache.parser_cache.clear() - - try: - api.preload_module('sys') - check_loaded() # compiled (c_builtin) modules shouldn't be in the cache. - api.preload_module('types', 'token') - check_loaded('types', 'token') - finally: - cache.parser_cache.update(old_cache) - - -def test_empty_script(): - assert api.Script('') - - -def test_line_number_errors(): - """ - Script should raise a ValueError if line/column numbers are not in a - valid range. - """ - s = 'hello' - # lines - with raises(ValueError): - api.Script(s, 2, 0) - with raises(ValueError): - api.Script(s, 0, 0) - - # columns - with raises(ValueError): - api.Script(s, 1, len(s) + 1) - with raises(ValueError): - api.Script(s, 1, -1) - - # ok - api.Script(s, 1, 0) - api.Script(s, 1, len(s)) - - -def _check_number(source, result='float'): - completions = api.Script(source).completions() - assert completions[0].parent().name == result - - -def test_completion_on_number_literals(): - # No completions on an int literal (is a float). - assert [c.name for c in api.Script('1.').completions()] \ - == ['and', 'if', 'in', 'is', 'not', 'or'] - - # Multiple points after an int literal basically mean that there's a float - # and a call after that. - _check_number('1..') - _check_number('1.0.') - - # power notation - _check_number('1.e14.') - _check_number('1.e-3.') - _check_number('9e3.') - assert api.Script('1.e3..').completions() == [] - assert api.Script('1.e-13..').completions() == [] - - -def test_completion_on_hex_literals(): - assert api.Script('0x1..').completions() == [] - _check_number('0x1.', 'int') # hexdecimal - # Completing binary literals doesn't work if they are not actually binary - # (invalid statements). - assert api.Script('0b2.b').completions() == [] - _check_number('0b1.', 'int') # binary - - _check_number('0x2e.', 'int') - _check_number('0xE7.', 'int') - _check_number('0xEa.', 'int') - # theoretically, but people can just check for syntax errors: - #assert api.Script('0x.').completions() == [] - - -def test_completion_on_complex_literals(): - assert api.Script('1j..').completions() == [] - _check_number('1j.', 'complex') - _check_number('44.j.', 'complex') - _check_number('4.0j.', 'complex') - # No dot no completion - I thought, but 4j is actually a literall after - # which a keyword like or is allowed. Good times, haha! - assert (set([c.name for c in api.Script('4j').completions()]) == - set(['if', 'and', 'in', 'is', 'not', 'or'])) - - -def test_goto_assignments_on_non_name(): - assert api.Script('for').goto_assignments() == [] - - assert api.Script('assert').goto_assignments() == [] - if is_py3: - assert api.Script('True').goto_assignments() == [] - else: - # In Python 2.7 True is still a name. - assert api.Script('True').goto_assignments()[0].description == 'instance True' - - -def test_goto_definitions_on_non_name(): - assert api.Script('import x', column=0).goto_definitions() == [] - - -def test_goto_definitions_on_generator(): - def_, = api.Script('def x(): yield 1\ny=x()\ny').goto_definitions() - assert def_.name == 'generator' - - -def test_goto_definition_not_multiple(): - """ - There should be only one Definition result if it leads back to the same - origin (e.g. instance method) - """ - - s = dedent('''\ - import random - class A(): - def __init__(self, a): - self.a = 3 - - def foo(self): - pass - - if random.randint(0, 1): - a = A(2) - else: - a = A(1) - a''') - assert len(api.Script(s).goto_definitions()) == 1 - - -def test_usage_description(): - descs = [u.description for u in api.Script("foo = ''; foo").usages()] - assert set(descs) == set(["foo = ''", 'foo']) - - -def test_get_line_code(): - def get_line_code(source, line=None, **kwargs): - return api.Script(source, line=line).completions()[0].get_line_code(**kwargs) - - # On builtin - assert get_line_code('') == '' - - # On custom code - first_line = 'def foo():\n' - line = ' foo' - code = '%s%s' % (first_line, line) - assert get_line_code(code) == first_line - - # With before/after - code = code + '\nother_line' - assert get_line_code(code, line=2) == first_line - assert get_line_code(code, line=2, after=1) == first_line + line + '\n' - assert get_line_code(code, line=2, after=2, before=1) == code - # Should just be the whole thing, since there are no more lines on both - # sides. - assert get_line_code(code, line=2, after=3, before=3) == code - - -def test_goto_assignments_follow_imports(): - code = dedent(""" - import inspect - inspect.isfunction""") - definition, = api.Script(code, column=0).goto_assignments(follow_imports=True) - assert 'inspect.py' in definition.module_path - assert (definition.line, definition.column) == (1, 0) - - definition, = api.Script(code).goto_assignments(follow_imports=True) - assert 'inspect.py' in definition.module_path - assert (definition.line, definition.column) > (1, 0) - - code = '''def param(p): pass\nparam(1)''' - start_pos = 1, len('def param(') - - script = api.Script(code, *start_pos) - definition, = script.goto_assignments(follow_imports=True) - assert (definition.line, definition.column) == start_pos - assert definition.name == 'p' - result, = definition.goto_assignments() - assert result.name == 'p' - result, = definition._goto_definitions() - assert result.name == 'int' - result, = result._goto_definitions() - assert result.name == 'int' - - definition, = script.goto_assignments() - assert (definition.line, definition.column) == start_pos - - d, = api.Script('a = 1\na').goto_assignments(follow_imports=True) - assert d.name == 'a' - - -def test_goto_module(): - def check(line, expected): - script = api.Script(path=path, line=line) - module, = script.goto_assignments() - assert module.module_path == expected - - base_path = os.path.join(os.path.dirname(__file__), 'simple_import') - path = os.path.join(base_path, '__init__.py') - - check(1, os.path.join(base_path, 'module.py')) - check(5, os.path.join(base_path, 'module2.py')) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_api_classes_follow_definition.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_api_classes_follow_definition.py deleted file mode 100644 index ffc0cb6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_api_classes_follow_definition.py +++ /dev/null @@ -1,62 +0,0 @@ -from itertools import chain - -import jedi -from ..helpers import cwd_at - - -def test_import_empty(): - """ github #340, return the full word. """ - completion = jedi.Script("import ").completions()[0] - definition = completion.follow_definition()[0] - assert definition - - -def check_follow_definition_types(source): - # nested import - completions = jedi.Script(source, path='some_path.py').completions() - defs = chain.from_iterable(c.follow_definition() for c in completions) - return [d.type for d in defs] - - -def test_follow_import_incomplete(): - """ - Completion on incomplete imports should always take the full completion - to do any evaluation. - """ - datetime = check_follow_definition_types("import itertool") - assert datetime == ['module'] - - # empty `from * import` parts - itert = jedi.Script("from itertools import ").completions() - definitions = [d for d in itert if d.name == 'chain'] - assert len(definitions) == 1 - assert [d.type for d in definitions[0].follow_definition()] == ['class'] - - # incomplete `from * import` part - datetime = check_follow_definition_types("from datetime import datetim") - assert set(datetime) == set(['class', 'instance']) # py33: builtin and pure py version - - # os.path check - ospath = check_follow_definition_types("from os.path import abspat") - assert ospath == ['function'] - - # alias - alias = check_follow_definition_types("import io as abcd; abcd") - assert alias == ['module'] - - -@cwd_at('test/completion/import_tree') -def test_follow_definition_nested_import(): - types = check_follow_definition_types("import pkg.mod1; pkg") - assert types == ['module'] - - types = check_follow_definition_types("import pkg.mod1; pkg.mod1") - assert types == ['module'] - - types = check_follow_definition_types("import pkg.mod1; pkg.mod1.a") - assert types == ['instance'] - - -def test_follow_definition_land_on_import(): - types = check_follow_definition_types("import datetime; datetim") - assert types == ['module'] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_call_signatures.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_call_signatures.py deleted file mode 100644 index c0fc976..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_call_signatures.py +++ /dev/null @@ -1,426 +0,0 @@ -from textwrap import dedent -import inspect -import warnings - -from ..helpers import TestCase -from jedi import Script -from jedi import cache -from jedi._compatibility import is_py33 - - -def assert_signature(source, expected_name, expected_index=0, line=None, column=None): - signatures = Script(source, line, column).call_signatures() - - assert len(signatures) <= 1 - - if not signatures: - assert expected_name is None, \ - 'There are no signatures, but `%s` expected.' % expected_name - else: - assert signatures[0].name == expected_name - assert signatures[0].index == expected_index - return signatures[0] - - -class TestCallSignatures(TestCase): - def _run_simple(self, source, name, index=0, column=None, line=1): - assert_signature(source, name, index, line, column) - - def test_valid_call(self): - assert_signature('str()', 'str', column=4) - - def test_simple(self): - run = self._run_simple - - # simple - s1 = "sorted(a, str(" - run(s1, 'sorted', 0, 7) - run(s1, 'sorted', 1, 9) - run(s1, 'sorted', 1, 10) - run(s1, 'sorted', 1, 11) - run(s1, 'str', 0, 14) - - s2 = "abs(), " - run(s2, 'abs', 0, 4) - run(s2, None, column=5) - run(s2, None) - - s3 = "abs()." - run(s3, None, column=5) - run(s3, None) - - def test_more_complicated(self): - run = self._run_simple - - s4 = 'abs(zip(), , set,' - run(s4, None, column=3) - run(s4, 'abs', 0, 4) - run(s4, 'zip', 0, 8) - run(s4, 'abs', 0, 9) - run(s4, 'abs', None, 10) - - s5 = "sorted(1,\nif 2:\n def a():" - run(s5, 'sorted', 0, 7) - run(s5, 'sorted', 1, 9) - - s6 = "str().center(" - run(s6, 'center', 0) - run(s6, 'str', 0, 4) - - s7 = "str().upper().center(" - s8 = "str(int[zip(" - run(s7, 'center', 0) - run(s8, 'zip', 0) - run(s8, 'str', 0, 8) - - run("import time; abc = time; abc.sleep(", 'sleep', 0) - - def test_issue_57(self): - # jedi #57 - s = "def func(alpha, beta): pass\n" \ - "func(alpha='101'," - self._run_simple(s, 'func', 0, column=13, line=2) - - def test_flows(self): - # jedi-vim #9 - self._run_simple("with open(", 'open', 0) - - # jedi-vim #11 - self._run_simple("for sorted(", 'sorted', 0) - self._run_simple("for s in sorted(", 'sorted', 0) - - def test_complex(self): - s = """ - def abc(a,b): - pass - - def a(self): - abc( - - if 1: - pass - """ - assert_signature(s, 'abc', 0, line=6, column=24) - s = """ - import re - def huhu(it): - re.compile( - return it * 2 - """ - assert_signature(s, 'compile', 0, line=4, column=31) - - # jedi-vim #70 - s = """def foo(""" - assert Script(s).call_signatures() == [] - - # jedi-vim #116 - s = """import itertools; test = getattr(itertools, 'chain'); test(""" - assert_signature(s, 'chain', 0) - - def test_call_signature_on_module(self): - """github issue #240""" - s = 'import datetime; datetime(' - # just don't throw an exception (if numpy doesn't exist, just ignore it) - assert Script(s).call_signatures() == [] - - def test_call_signatures_empty_parentheses_pre_space(self): - s = dedent("""\ - def f(a, b): - pass - f( )""") - assert_signature(s, 'f', 0, line=3, column=3) - - def test_multiple_signatures(self): - s = dedent("""\ - if x: - def f(a, b): - pass - else: - def f(a, b): - pass - f(""") - assert len(Script(s).call_signatures()) == 2 - - def test_call_signatures_whitespace(self): - s = dedent("""\ - abs( - def x(): - pass - """) - assert_signature(s, 'abs', 0, line=1, column=5) - - def test_decorator_in_class(self): - """ - There's still an implicit param, with a decorator. - Github issue #319. - """ - s = dedent("""\ - def static(func): - def wrapped(obj, *args): - return f(type(obj), *args) - return wrapped - - class C(object): - @static - def test(cls): - return 10 - - C().test(""") - - signatures = Script(s).call_signatures() - assert len(signatures) == 1 - x = [p.description for p in signatures[0].params] - assert x == ['param *args'] - - def test_additional_brackets(self): - assert_signature('str((', 'str', 0) - - def test_unterminated_strings(self): - assert_signature('str(";', 'str', 0) - - def test_whitespace_before_bracket(self): - assert_signature('str (', 'str', 0) - assert_signature('str (";', 'str', 0) - assert_signature('str\n(', None) - - def test_brackets_in_string_literals(self): - assert_signature('str (" (', 'str', 0) - assert_signature('str (" )', 'str', 0) - - def test_function_definitions_should_break(self): - """ - Function definitions (and other tokens that cannot exist within call - signatures) should break and not be able to return a call signature. - """ - assert_signature('str(\ndef x', 'str', 0) - assert not Script('str(\ndef x(): pass').call_signatures() - - def test_flow_call(self): - assert not Script('if (1').call_signatures() - - def test_chained_calls(self): - source = dedent(''' - class B(): - def test2(self, arg): - pass - - class A(): - def test1(self): - return B() - - A().test1().test2(''') - - assert_signature(source, 'test2', 0) - - def test_return(self): - source = dedent(''' - def foo(): - return '.'.join()''') - - assert_signature(source, 'join', 0, column=len(" return '.'.join(")) - - -class TestParams(TestCase): - def params(self, source, line=None, column=None): - signatures = Script(source, line, column).call_signatures() - assert len(signatures) == 1 - return signatures[0].params - - def test_param_name(self): - if not is_py33: - p = self.params('''int(''') - # int is defined as: `int(x[, base])` - assert p[0].name == 'x' - # `int` docstring has been redefined: - # http://bugs.python.org/issue14783 - # TODO have multiple call signatures for int (like in the docstr) - #assert p[1].name == 'base' - - p = self.params('''open(something,''') - assert p[0].name in ['file', 'name'] - assert p[1].name == 'mode' - - def test_builtins(self): - """ - The self keyword should be visible even for builtins, if not - instantiated. - """ - p = self.params('str.endswith(') - assert p[0].name == 'self' - assert p[1].name == 'suffix' - p = self.params('str().endswith(') - assert p[0].name == 'suffix' - - -def test_signature_is_definition(): - """ - Through inheritance, a call signature is a sub class of Definition. - Check if the attributes match. - """ - s = """class Spam(): pass\nSpam""" - signature = Script(s + '(').call_signatures()[0] - definition = Script(s + '(', column=0).goto_definitions()[0] - signature.line == 1 - signature.column == 6 - - # Now compare all the attributes that a CallSignature must also have. - for attr_name in dir(definition): - dont_scan = ['defined_names', 'parent', 'goto_assignments', 'params'] - if attr_name.startswith('_') or attr_name in dont_scan: - continue - - # Might trigger some deprecation warnings. - with warnings.catch_warnings(record=True): - attribute = getattr(definition, attr_name) - signature_attribute = getattr(signature, attr_name) - if inspect.ismethod(attribute): - assert attribute() == signature_attribute() - else: - assert attribute == signature_attribute - - -def test_no_signature(): - # str doesn't have a __call__ method - assert Script('str()(').call_signatures() == [] - - s = dedent("""\ - class X(): - pass - X()(""") - assert Script(s).call_signatures() == [] - assert len(Script(s, column=2).call_signatures()) == 1 - assert Script('').call_signatures() == [] - - -def test_dict_literal_in_incomplete_call(): - source = """\ - import json - - def foo(): - json.loads( - - json.load.return_value = {'foo': [], - 'bar': True} - - c = Foo() - """ - - script = Script(dedent(source), line=4, column=15) - assert script.call_signatures() - - -def test_completion_interference(): - """Seems to cause problems, see also #396.""" - cache.parser_cache.pop(None, None) - assert Script('open(').call_signatures() - - # complete something usual, before doing the same call_signatures again. - assert Script('from datetime import ').completions() - - assert Script('open(').call_signatures() - - -def test_keyword_argument_index(): - def get(source, column=None): - return Script(source, column=column).call_signatures()[0] - - assert get('sorted([], key=a').index == 2 - assert get('sorted([], key=').index == 2 - assert get('sorted([], no_key=a').index is None - - kw_func = 'def foo(a, b): pass\nfoo(b=3, a=4)' - assert get(kw_func, column=len('foo(b')).index == 0 - assert get(kw_func, column=len('foo(b=')).index == 1 - assert get(kw_func, column=len('foo(b=3, a=')).index == 0 - - kw_func_simple = 'def foo(a, b): pass\nfoo(b=4)' - assert get(kw_func_simple, column=len('foo(b')).index == 0 - assert get(kw_func_simple, column=len('foo(b=')).index == 1 - - args_func = 'def foo(*kwargs): pass\n' - assert get(args_func + 'foo(a').index == 0 - assert get(args_func + 'foo(a, b').index == 0 - - kwargs_func = 'def foo(**kwargs): pass\n' - assert get(kwargs_func + 'foo(a=2').index == 0 - assert get(kwargs_func + 'foo(a=2, b=2').index == 0 - - both = 'def foo(*args, **kwargs): pass\n' - assert get(both + 'foo(a=2').index == 1 - assert get(both + 'foo(a=2, b=2').index == 1 - assert get(both + 'foo(a=2, b=2)', column=len('foo(b=2, a=2')).index == 1 - assert get(both + 'foo(a, b, c').index == 0 - - -def test_bracket_start(): - def bracket_start(src): - signatures = Script(src).call_signatures() - assert len(signatures) == 1 - return signatures[0].bracket_start - - assert bracket_start('str(') == (1, 3) - - -def test_different_caller(): - """ - It's possible to not use names, but another function result or an array - index and then get the call signature of it. - """ - - assert_signature('[str][0](', 'str', 0) - assert_signature('[str][0]()', 'str', 0, column=len('[str][0](')) - - assert_signature('(str)(', 'str', 0) - assert_signature('(str)()', 'str', 0, column=len('(str)(')) - - -def test_in_function(): - code = dedent('''\ - class X(): - @property - def func(''') - assert not Script(code).call_signatures() - - -def test_lambda_params(): - code = dedent('''\ - my_lambda = lambda x: x+1 - my_lambda(1)''') - sig, = Script(code, column=11).call_signatures() - assert sig.index == 0 - assert sig.name == '' - assert [p.name for p in sig.params] == ['x'] - - -def test_class_creation(): - code = dedent('''\ - class X(): - def __init__(self, foo, bar): - self.foo = foo - ''') - sig, = Script(code + 'X(').call_signatures() - assert sig.index == 0 - assert sig.name == 'X' - assert [p.name for p in sig.params] == ['foo', 'bar'] - - sig, = Script(code + 'X.__init__(').call_signatures() - assert [p.name for p in sig.params] == ['self', 'foo', 'bar'] - sig, = Script(code + 'X().__init__(').call_signatures() - assert [p.name for p in sig.params] == ['foo', 'bar'] - - -def test_call_magic_method(): - code = dedent('''\ - class X(): - def __call__(self, baz): - pass - ''') - sig, = Script(code + 'X()(').call_signatures() - assert sig.index == 0 - assert sig.name == 'X' - assert [p.name for p in sig.params] == ['baz'] - - sig, = Script(code + 'X.__call__(').call_signatures() - assert [p.name for p in sig.params] == ['self', 'baz'] - sig, = Script(code + 'X().__call__(').call_signatures() - assert [p.name for p in sig.params] == ['baz'] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_classes.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_classes.py deleted file mode 100644 index cc01c2a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_classes.py +++ /dev/null @@ -1,393 +0,0 @@ -""" Test all things related to the ``jedi.api_classes`` module. -""" - -from textwrap import dedent -from inspect import cleandoc - -import pytest - -from jedi import Script, __doc__ as jedi_doc, names -from ..helpers import cwd_at -from ..helpers import TestCase - - -def test_is_keyword(): - #results = Script('import ', 1, 1, None).goto_definitions() - #assert len(results) == 1 and results[0].is_keyword is True - results = Script('str', 1, 1, None).goto_definitions() - assert len(results) == 1 and results[0].is_keyword is False - - -def make_definitions(): - """ - Return a list of definitions for parametrized tests. - - :rtype: [jedi.api_classes.BaseDefinition] - """ - source = dedent(""" - import sys - - class C: - pass - - x = C() - - def f(): - pass - - def g(): - yield - - h = lambda: None - """) - - definitions = [] - definitions += names(source) - - source += dedent(""" - variable = sys or C or x or f or g or g() or h""") - lines = source.splitlines() - script = Script(source, len(lines), len('variable'), None) - definitions += script.goto_definitions() - - script2 = Script(source, 4, len('class C'), None) - definitions += script2.usages() - - source_param = "def f(a): return a" - script_param = Script(source_param, 1, len(source_param), None) - definitions += script_param.goto_assignments() - - return definitions - - -@pytest.mark.parametrize('definition', make_definitions()) -def test_basedefinition_type(definition): - assert definition.type in ('module', 'class', 'instance', 'function', - 'generator', 'statement', 'import', 'param') - - -def test_basedefinition_type_import(): - def get_types(source, **kwargs): - return set([t.type for t in Script(source, **kwargs).completions()]) - - # import one level - assert get_types('import t') == set(['module']) - assert get_types('import ') == set(['module']) - assert get_types('import datetime; datetime') == set(['module']) - - # from - assert get_types('from datetime import timedelta') == set(['class']) - assert get_types('from datetime import timedelta; timedelta') == set(['class']) - assert get_types('from json import tool') == set(['module']) - assert get_types('from json import tool; tool') == set(['module']) - - # import two levels - assert get_types('import json.tool; json') == set(['module']) - assert get_types('import json.tool; json.tool') == set(['module']) - assert get_types('import json.tool; json.tool.main') == set(['function']) - assert get_types('import json.tool') == set(['module']) - assert get_types('import json.tool', column=9) == set(['module']) - - -def test_function_call_signature_in_doc(): - defs = Script(""" - def f(x, y=1, z='a'): - pass - f""").goto_definitions() - doc = defs[0].docstring() - assert "f(x, y=1, z='a')" in str(doc) - - -def test_class_call_signature(): - defs = Script(""" - class Foo: - def __init__(self, x, y=1, z='a'): - pass - Foo""").goto_definitions() - doc = defs[0].docstring() - assert "Foo(self, x, y=1, z='a')" in str(doc) - - -def test_position_none_if_builtin(): - gotos = Script('import sys; sys.path').goto_assignments() - assert gotos[0].line is None - assert gotos[0].column is None - - -@cwd_at('.') -def test_completion_docstring(): - """ - Jedi should follow imports in certain conditions - """ - def docstr(src, result): - c = Script(src).completions()[0] - assert c.docstring(raw=True, fast=False) == cleandoc(result) - - c = Script('import jedi\njed').completions()[0] - assert c.docstring(fast=False) == cleandoc(jedi_doc) - - docstr('import jedi\njedi.Scr', cleandoc(Script.__doc__)) - - docstr('abcd=3;abcd', '') - docstr('"hello"\nabcd=3\nabcd', '') - docstr(dedent(''' - def x(): - "hello" - 0 - x'''), - 'hello' - ) - docstr(dedent(''' - def x(): - "hello";0 - x'''), - 'hello' - ) - # Shouldn't work with a tuple. - docstr(dedent(''' - def x(): - "hello",0 - x'''), - '' - ) - # Should also not work if we rename something. - docstr(dedent(''' - def x(): - "hello" - y = x - y'''), - '' - ) - - -def test_completion_params(): - c = Script('import string; string.capwords').completions()[0] - assert [p.name for p in c.params] == ['s', 'sep'] - - -def test_signature_params(): - def check(defs): - params = defs[0].params - assert len(params) == 1 - assert params[0].name == 'bar' - - s = dedent(''' - def foo(bar): - pass - foo''') - - check(Script(s).goto_definitions()) - - check(Script(s).goto_assignments()) - check(Script(s + '\nbar=foo\nbar').goto_assignments()) - - -def test_param_endings(): - """ - Params should be represented without the comma and whitespace they have - around them. - """ - sig = Script('def x(a, b=5, c=""): pass\n x(').call_signatures()[0] - assert [p.description for p in sig.params] == ['param a', 'param b=5', 'param c=""'] - - -class TestIsDefinition(TestCase): - def _def(self, source, index=-1): - return names(dedent(source), references=True, all_scopes=True)[index] - - def _bool_is_definitions(self, source): - ns = names(dedent(source), references=True, all_scopes=True) - # Assure that names are definitely sorted. - ns = sorted(ns, key=lambda name: (name.line, name.column)) - return [name.is_definition() for name in ns] - - def test_name(self): - d = self._def('name') - assert d.name == 'name' - assert not d.is_definition() - - def test_stmt(self): - src = 'a = f(x)' - d = self._def(src, 0) - assert d.name == 'a' - assert d.is_definition() - d = self._def(src, 1) - assert d.name == 'f' - assert not d.is_definition() - d = self._def(src) - assert d.name == 'x' - assert not d.is_definition() - - def test_import(self): - assert self._bool_is_definitions('import x as a') == [False, True] - assert self._bool_is_definitions('from x import y') == [False, True] - assert self._bool_is_definitions('from x.z import y') == [False, False, True] - - -class TestParent(TestCase): - def _parent(self, source, line=None, column=None): - def_, = Script(dedent(source), line, column).goto_assignments() - return def_.parent() - - def test_parent(self): - parent = self._parent('foo=1\nfoo') - assert parent.type == 'module' - - parent = self._parent(''' - def spam(): - if 1: - y=1 - y''') - assert parent.name == 'spam' - assert parent.parent().type == 'module' - - def test_on_function(self): - parent = self._parent('''\ - def spam(): - pass''', 1, len('def spam')) - assert parent.name == '' - assert parent.type == 'module' - - def test_parent_on_completion(self): - parent = Script(dedent('''\ - class Foo(): - def bar(): pass - Foo().bar''')).completions()[0].parent() - assert parent.name == 'Foo' - assert parent.type == 'class' - - parent = Script('str.join').completions()[0].parent() - assert parent.name == 'str' - assert parent.type == 'class' - - -def test_type(): - for c in Script('a = [str()]; a[0].').completions(): - if c.name == '__class__': - assert c.type == 'class' - else: - assert c.type in ('function', 'instance') - - # Github issue #397, type should never raise an error. - for c in Script('import os; os.path.').completions(): - assert c.type - -def test_type_II(): - """ - GitHub Issue #833, `keyword`s are seen as `module`s - """ - for c in Script('f').completions(): - if c.name == 'for': - assert c.type == 'keyword' - - -class TestGotoAssignments(TestCase): - """ - This tests the BaseDefinition.goto_assignments function, not the jedi - function. They are not really different in functionality, but really - different as an implementation. - """ - def test_repetition(self): - defs = names('a = 1; a', references=True, definitions=False) - # Repeat on the same variable. Shouldn't change once we're on a - # definition. - for _ in range(3): - assert len(defs) == 1 - ass = defs[0].goto_assignments() - assert ass[0].description == 'a = 1' - - def test_named_params(self): - src = """\ - def foo(a=1, bar=2): - pass - foo(bar=1) - """ - bar = names(dedent(src), references=True)[-1] - param = bar.goto_assignments()[0] - assert (param.line, param.column) == (1, 13) - assert param.type == 'param' - - def test_class_call(self): - src = 'from threading import Thread; Thread(group=1)' - n = names(src, references=True)[-1] - assert n.name == 'group' - param_def = n.goto_assignments()[0] - assert param_def.name == 'group' - assert param_def.type == 'param' - - def test_parentheses(self): - n = names('("").upper', references=True)[-1] - assert n.goto_assignments()[0].name == 'upper' - - def test_import(self): - nms = names('from json import load', references=True) - assert nms[0].name == 'json' - assert nms[0].type == 'module' - n = nms[0].goto_assignments()[0] - assert n.name == 'json' - assert n.type == 'module' - - assert nms[1].name == 'load' - assert nms[1].type == 'function' - n = nms[1].goto_assignments()[0] - assert n.name == 'load' - assert n.type == 'function' - - nms = names('import os; os.path', references=True) - assert nms[0].name == 'os' - assert nms[0].type == 'module' - n = nms[0].goto_assignments()[0] - assert n.name == 'os' - assert n.type == 'module' - - n = nms[2].goto_assignments()[0] - assert n.name == 'path' - assert n.type == 'module' - - nms = names('import os.path', references=True) - n = nms[0].goto_assignments()[0] - assert n.name == 'os' - assert n.type == 'module' - n = nms[1].goto_assignments()[0] - # This is very special, normally the name doesn't chance, but since - # os.path is a sys.modules hack, it does. - assert n.name in ('ntpath', 'posixpath', 'os2emxpath') - assert n.type == 'module' - - def test_import_alias(self): - nms = names('import json as foo', references=True) - assert nms[0].name == 'json' - assert nms[0].type == 'module' - assert nms[0]._name.tree_name.parent.type == 'dotted_as_name' - n = nms[0].goto_assignments()[0] - assert n.name == 'json' - assert n.type == 'module' - assert n._name._context.tree_node.type == 'file_input' - - assert nms[1].name == 'foo' - assert nms[1].type == 'module' - assert nms[1]._name.tree_name.parent.type == 'dotted_as_name' - ass = nms[1].goto_assignments() - assert len(ass) == 1 - assert ass[0].name == 'json' - assert ass[0].type == 'module' - assert ass[0]._name._context.tree_node.type == 'file_input' - - -def test_added_equals_to_params(): - def run(rest_source): - source = dedent(""" - def foo(bar, baz): - pass - """) - results = Script(source + rest_source).completions() - assert len(results) == 1 - return results[0] - - assert run('foo(bar').name_with_symbols == 'bar=' - assert run('foo(bar').complete == '=' - assert run('foo(bar, baz').complete == '=' - assert run(' bar').name_with_symbols == 'bar' - assert run(' bar').complete == '' - x = run('foo(bar=isins').name_with_symbols - assert x == 'isinstance' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_completion.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_completion.py deleted file mode 100644 index 6cd7e04..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_completion.py +++ /dev/null @@ -1,49 +0,0 @@ -from textwrap import dedent -from jedi import Script - - -def test_in_whitespace(): - code = dedent(''' - def x(): - pass''') - assert len(Script(code, column=2).completions()) > 20 - - -def test_empty_init(): - """This was actually an issue.""" - code = dedent('''\ - class X(object): pass - X(''') - assert Script(code).completions() - - -def test_in_empty_space(): - code = dedent('''\ - class X(object): - def __init__(self): - hello - ''') - comps = Script(code, 3, 7).completions() - self, = [c for c in comps if c.name == 'self'] - assert self.name == 'self' - def_, = self._goto_definitions() - assert def_.name == 'X' - - -def test_indent_context(): - """ - If an INDENT is the next supposed token, we should still be able to - complete. - """ - code = 'if 1:\nisinstanc' - comp, = Script(code).completions() - assert comp.name == 'isinstance' - - -def test_keyword_context(): - def get_names(*args, **kwargs): - return [d.name for d in Script(*args, **kwargs).completions()] - - names = get_names('if 1:\n pass\n') - assert 'if' in names - assert 'elif' in names diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_defined_names.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_defined_names.py deleted file mode 100644 index b982594..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_defined_names.py +++ /dev/null @@ -1,92 +0,0 @@ -""" -Tests for `api.defined_names`. -""" - -from textwrap import dedent - -from jedi import names -from ..helpers import TestCase - - -class TestDefinedNames(TestCase): - def assert_definition_names(self, definitions, names_): - assert [d.name for d in definitions] == names_ - - def check_defined_names(self, source, names_): - definitions = names(dedent(source)) - self.assert_definition_names(definitions, names_) - return definitions - - def test_get_definitions_flat(self): - self.check_defined_names(""" - import module - class Class: - pass - def func(): - pass - data = None - """, ['module', 'Class', 'func', 'data']) - - def test_dotted_assignment(self): - self.check_defined_names(""" - x = Class() - x.y.z = None - """, ['x', 'z']) # TODO is this behavior what we want? - - def test_multiple_assignment(self): - self.check_defined_names(""" - x = y = None - """, ['x', 'y']) - - def test_multiple_imports(self): - self.check_defined_names(""" - from module import a, b - from another_module import * - """, ['a', 'b']) - - def test_nested_definitions(self): - definitions = self.check_defined_names(""" - class Class: - def f(): - pass - def g(): - pass - """, ['Class']) - subdefinitions = definitions[0].defined_names() - self.assert_definition_names(subdefinitions, ['f', 'g']) - self.assertEqual([d.full_name for d in subdefinitions], - ['__main__.Class.f', '__main__.Class.g']) - - def test_nested_class(self): - definitions = self.check_defined_names(""" - class L1: - class L2: - class L3: - def f(): pass - def f(): pass - def f(): pass - def f(): pass - """, ['L1', 'f']) - subdefs = definitions[0].defined_names() - subsubdefs = subdefs[0].defined_names() - self.assert_definition_names(subdefs, ['L2', 'f']) - self.assert_definition_names(subsubdefs, ['L3', 'f']) - self.assert_definition_names(subsubdefs[0].defined_names(), ['f']) - - -def test_follow_imports(): - # github issue #344 - imp = names('import datetime')[0] - assert imp.name == 'datetime' - datetime_names = [str(d.name) for d in imp.defined_names()] - assert 'timedelta' in datetime_names - - -def test_names_twice(): - source = dedent(''' - def lol(): - pass - ''') - - defs = names(source=source) - assert defs[0].defined_names() == [] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_full_name.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_full_name.py deleted file mode 100644 index d2ad9d0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_full_name.py +++ /dev/null @@ -1,104 +0,0 @@ -""" -Tests for :attr:`.BaseDefinition.full_name`. - -There are three kinds of test: - -#. Test classes derived from :class:`MixinTestFullName`. - Child class defines :attr:`.operation` to alter how - the api definition instance is created. - -#. :class:`TestFullDefinedName` is to test combination of - ``obj.full_name`` and ``jedi.defined_names``. - -#. Misc single-function tests. -""" - -import textwrap - -import pytest - -import jedi -from ..helpers import TestCase - - -class MixinTestFullName(object): - operation = None - - def check(self, source, desired): - script = jedi.Script(textwrap.dedent(source)) - definitions = getattr(script, type(self).operation)() - for d in definitions: - self.assertEqual(d.full_name, desired) - - def test_os_path_join(self): - self.check('import os; os.path.join', 'os.path.join') - - def test_builtin(self): - self.check('TypeError', 'TypeError') - - -class TestFullNameWithGotoDefinitions(MixinTestFullName, TestCase): - operation = 'goto_definitions' - - @pytest.mark.skipif('sys.version_info[0] < 3', reason='Python 2 also yields None.') - def test_tuple_mapping(self): - self.check(""" - import re - any_re = re.compile('.*') - any_re""", '_sre.SRE_Pattern') - - def test_from_import(self): - self.check('from os import path', 'os.path') - - -class TestFullNameWithCompletions(MixinTestFullName, TestCase): - operation = 'completions' - - -class TestFullDefinedName(TestCase): - """ - Test combination of ``obj.full_name`` and ``jedi.defined_names``. - """ - - def check(self, source, desired): - definitions = jedi.names(textwrap.dedent(source)) - full_names = [d.full_name for d in definitions] - self.assertEqual(full_names, desired) - - def test_local_names(self): - self.check(""" - def f(): pass - class C: pass - """, ['__main__.f', '__main__.C']) - - def test_imports(self): - self.check(""" - import os - from os import path - from os.path import join - from os import path as opath - """, ['os', 'os.path', 'os.path.join', 'os.path']) - - -def test_sub_module(): - """ - ``full_name needs to check sys.path to actually find it's real path module - path. - """ - defs = jedi.Script('from jedi.api import classes; classes').goto_definitions() - assert [d.full_name for d in defs] == ['jedi.api.classes'] - defs = jedi.Script('import jedi.api; jedi.api').goto_definitions() - assert [d.full_name for d in defs] == ['jedi.api'] - - -def test_os_path(): - d, = jedi.Script('from os.path import join').completions() - assert d.full_name == 'os.path.join' - d, = jedi.Script('import os.p').completions() - assert d.full_name == 'os.path' - - -def test_os_issues(): - """Issue #873""" - c, = jedi.Script('import os\nos.nt''').completions() - assert c.full_name == 'nt' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_interpreter.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_interpreter.py deleted file mode 100644 index a4c0311..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_interpreter.py +++ /dev/null @@ -1,300 +0,0 @@ -""" -Tests of ``jedi.api.Interpreter``. -""" -import pytest - -import jedi -from jedi._compatibility import is_py33, py_version -from jedi.evaluate.compiled import mixed - - -if py_version > 30: - def exec_(source, global_map): - exec(source, global_map) -else: - eval(compile("""def exec_(source, global_map): - exec source in global_map """, 'blub', 'exec')) - - -class _GlobalNameSpace(): - class SideEffectContainer(): - pass - - -def get_completion(source, namespace): - i = jedi.Interpreter(source, [namespace]) - completions = i.completions() - assert len(completions) == 1 - return completions[0] - - -def test_builtin_details(): - import keyword - - class EmptyClass: - pass - - variable = EmptyClass() - - def func(): - pass - - cls = get_completion('EmptyClass', locals()) - var = get_completion('variable', locals()) - f = get_completion('func', locals()) - m = get_completion('keyword', locals()) - assert cls.type == 'class' - assert var.type == 'instance' - assert f.type == 'function' - assert m.type == 'module' - - -def test_numpy_like_non_zero(): - """ - Numpy-like array can't be caster to bool and need to be compacre with - `is`/`is not` and not `==`/`!=` - """ - - class NumpyNonZero: - - def __zero__(self): - raise ValueError('Numpy arrays would raise and tell you to use .any() or all()') - def __bool__(self): - raise ValueError('Numpy arrays would raise and tell you to use .any() or all()') - - class NumpyLike: - - def __eq__(self, other): - return NumpyNonZero() - - def something(self): - pass - - x = NumpyLike() - d = {'a': x} - - # just assert these do not raise. They (strangely) trigger different - # codepath - get_completion('d["a"].some', {'d':d}) - get_completion('x.some', {'x':x}) - - -def test_nested_resolve(): - class XX(): - def x(): - pass - - cls = get_completion('XX', locals()) - func = get_completion('XX.x', locals()) - assert (func.line, func.column) == (cls.line + 1, 12) - - -def test_side_effect_completion(): - """ - In the repl it's possible to cause side effects that are not documented in - Python code, however we want references to Python code as well. Therefore - we need some mixed kind of magic for tests. - """ - _GlobalNameSpace.SideEffectContainer.foo = 1 - side_effect = get_completion('SideEffectContainer', _GlobalNameSpace.__dict__) - - # It's a class that contains MixedObject. - context, = side_effect._name.infer() - assert isinstance(context, mixed.MixedObject) - foo = get_completion('SideEffectContainer.foo', _GlobalNameSpace.__dict__) - assert foo.name == 'foo' - - -def _assert_interpreter_complete(source, namespace, completions, - **kwds): - script = jedi.Interpreter(source, [namespace], **kwds) - cs = script.completions() - actual = [c.name for c in cs] - assert sorted(actual) == sorted(completions) - - -def test_complete_raw_function(): - from os.path import join - _assert_interpreter_complete('join("").up', - locals(), - ['upper']) - - -def test_complete_raw_function_different_name(): - from os.path import join as pjoin - _assert_interpreter_complete('pjoin("").up', - locals(), - ['upper']) - - -def test_complete_raw_module(): - import os - _assert_interpreter_complete('os.path.join("a").up', - locals(), - ['upper']) - - -def test_complete_raw_instance(): - import datetime - dt = datetime.datetime(2013, 1, 1) - completions = ['time', 'timetz', 'timetuple'] - if is_py33: - completions += ['timestamp'] - _assert_interpreter_complete('(dt - dt).ti', - locals(), - completions) - - -def test_list(): - array = ['haha', 1] - _assert_interpreter_complete('array[0].uppe', - locals(), - ['upper']) - _assert_interpreter_complete('array[0].real', - locals(), - []) - - # something different, no index given, still just return the right - _assert_interpreter_complete('array[int].real', - locals(), - ['real']) - _assert_interpreter_complete('array[int()].real', - locals(), - ['real']) - # inexistent index - _assert_interpreter_complete('array[2].upper', - locals(), - ['upper']) - - -def test_slice(): - class Foo1(): - bar = [] - baz = 'xbarx' - _assert_interpreter_complete('getattr(Foo1, baz[1:-1]).append', - locals(), - ['append']) - - -def test_getitem_side_effects(): - class Foo2(): - def __getitem__(self, index): - # Possible side effects here, should therefore not call this. - if True: - raise NotImplementedError() - return index - - foo = Foo2() - _assert_interpreter_complete('foo["asdf"].upper', locals(), ['upper']) - - -def test_property_error_oldstyle(): - lst = [] - class Foo3(): - @property - def bar(self): - lst.append(1) - raise ValueError - - foo = Foo3() - _assert_interpreter_complete('foo.bar', locals(), ['bar']) - _assert_interpreter_complete('foo.bar.baz', locals(), []) - - # There should not be side effects - assert lst == [] - - -def test_property_error_newstyle(): - lst = [] - class Foo3(object): - @property - def bar(self): - lst.append(1) - raise ValueError - - foo = Foo3() - _assert_interpreter_complete('foo.bar', locals(), ['bar']) - _assert_interpreter_complete('foo.bar.baz', locals(), []) - - # There should not be side effects - assert lst == [] - - -def test_param_completion(): - def foo(bar): - pass - - lambd = lambda xyz: 3 - - _assert_interpreter_complete('foo(bar', locals(), ['bar']) - # TODO we're not yet using the Python3.5 inspect.signature, yet. - assert not jedi.Interpreter('lambd(xyz', [locals()]).completions() - - -def test_endless_yield(): - lst = [1] * 10000 - # If iterating over lists it should not be possible to take an extremely - # long time. - _assert_interpreter_complete('list(lst)[9000].rea', locals(), ['real']) - - -@pytest.mark.skipif('py_version < 33', reason='inspect.signature was created in 3.3.') -def test_completion_params(): - foo = lambda a, b=3: None - - script = jedi.Interpreter('foo', [locals()]) - c, = script.completions() - assert [p.name for p in c.params] == ['a', 'b'] - assert c.params[0]._goto_definitions() == [] - t, = c.params[1]._goto_definitions() - assert t.name == 'int' - - -@pytest.mark.skipif('py_version < 33', reason='inspect.signature was created in 3.3.') -def test_completion_param_annotations(): - # Need to define this function not directly in Python. Otherwise Jedi is to - # clever and uses the Python code instead of the signature object. - code = 'def foo(a: 1, b: str, c: int = 1.0): pass' - exec_(code, locals()) - script = jedi.Interpreter('foo', [locals()]) - c, = script.completions() - a, b, c = c.params - assert a._goto_definitions() == [] - assert [d.name for d in b._goto_definitions()] == ['str'] - assert set([d.name for d in c._goto_definitions()]) == set(['int', 'float']) - - -def test_more_complex_instances(): - class Something: - def foo(self, other): - return self - - class Base(): - def wow(self): - return Something() - - #script = jedi.Interpreter('Base().wow().foo', [locals()]) - #c, = script.completions() - #assert c.name == 'foo' - - x = Base() - script = jedi.Interpreter('x.wow().foo', [locals()]) - c, = script.completions() - assert c.name == 'foo' - - -def test_repr_execution_issue(): - """ - Anticipate inspect.getfile executing a __repr__ of all kinds of objects. - See also #919. - """ - class ErrorRepr: - def __repr__(self): - raise Exception('xyz') - - er = ErrorRepr() - - script = jedi.Interpreter('er', [locals()]) - d, = script.goto_definitions() - assert d.name == 'ErrorRepr' - assert d.type == 'instance' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_unicode.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_unicode.py deleted file mode 100644 index bcd8ad4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_unicode.py +++ /dev/null @@ -1,66 +0,0 @@ -# -*- coding: utf-8 -*- -""" -All character set and unicode related tests. -""" -from jedi import Script -from jedi._compatibility import u, unicode - - -def test_unicode_script(): - """ normally no unicode objects are being used. (<=2.7) """ - s = unicode("import datetime; datetime.timedelta") - completions = Script(s).completions() - assert len(completions) - assert type(completions[0].description) is unicode - - s = u("author='öä'; author") - completions = Script(s).completions() - x = completions[0].description - assert type(x) is unicode - - s = u("#-*- coding: iso-8859-1 -*-\nauthor='öä'; author") - s = s.encode('latin-1') - completions = Script(s).completions() - assert type(completions[0].description) is unicode - - -def test_unicode_attribute(): - """ github jedi-vim issue #94 """ - s1 = u('#-*- coding: utf-8 -*-\nclass Person():\n' - ' name = "e"\n\nPerson().name.') - completions1 = Script(s1).completions() - assert 'strip' in [c.name for c in completions1] - s2 = u('#-*- coding: utf-8 -*-\nclass Person():\n' - ' name = "é"\n\nPerson().name.') - completions2 = Script(s2).completions() - assert 'strip' in [c.name for c in completions2] - - -def test_multibyte_script(): - """ `jedi.Script` must accept multi-byte string source. """ - try: - code = u("import datetime; datetime.d") - comment = u("# multi-byte comment あいうえおä") - s = (u('%s\n%s') % (code, comment)).encode('utf-8') - except NameError: - pass # python 3 has no unicode method - else: - assert len(Script(s, 1, len(code)).completions()) - - -def test_goto_definition_at_zero(): - """At zero usually sometimes raises unicode issues.""" - assert Script("a", 1, 1).goto_definitions() == [] - s = Script("str", 1, 1).goto_definitions() - assert len(s) == 1 - assert list(s)[0].description == 'class str' - assert Script("", 1, 0).goto_definitions() == [] - - -def test_complete_at_zero(): - s = Script("str", 1, 3).completions() - assert len(s) == 1 - assert list(s)[0].name == 'str' - - s = Script("", 1, 0).completions() - assert len(s) > 0 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_usages.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_usages.py deleted file mode 100644 index 1325e41..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_api/test_usages.py +++ /dev/null @@ -1,6 +0,0 @@ -import jedi - - -def test_import_usage(): - s = jedi.Script("from .. import foo", line=1, column=18, path="foo.py") - assert [usage.line for usage in s.usages()] == [1] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/absolute_import/local_module.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/absolute_import/local_module.py deleted file mode 100644 index aa4bf00..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/absolute_import/local_module.py +++ /dev/null @@ -1,14 +0,0 @@ -""" -This is a module that imports the *standard library* unittest, -despite there being a local "unittest" module. It specifies that it -wants the stdlib one with the ``absolute_import`` __future__ import. - -The twisted equivalent of this module is ``twisted.trial._synctest``. -""" -from __future__ import absolute_import - -import unittest - - -class Assertions(unittest.TestCase): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/absolute_import/unittest.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/absolute_import/unittest.py deleted file mode 100644 index eee1e93..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/absolute_import/unittest.py +++ /dev/null @@ -1,14 +0,0 @@ -""" -This is a module that shadows a builtin (intentionally). - -It imports a local module, which in turn imports stdlib unittest (the -name shadowed by this module). If that is properly resolved, there's -no problem. However, if jedi doesn't understand absolute_imports, it -will get this module again, causing infinite recursion. -""" -from local_module import Assertions - - -class TestCase(Assertions): - def test(self): - self.assertT diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/app b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/app deleted file mode 100644 index 7394d2d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/app +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/python - -import sys -sys.path[0:0] = [ - '/usr/lib/python3.4/site-packages', - '/tmp/.buildout/eggs/important_package.egg' -] - -import important_package - -if __name__ == '__main__': - sys.exit(important_package.main()) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/binary_file b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/binary_file deleted file mode 100644 index f1ad755..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/binary_file +++ /dev/null @@ -1 +0,0 @@ -PNG diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/empty_file b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/bin/empty_file deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/buildout.cfg b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/buildout.cfg deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/src/proj_name/module_name.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/buildout_project/src/proj_name/module_name.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask/__init__.py deleted file mode 100644 index e876bc1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask/ext/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask/ext/__init__.py deleted file mode 100644 index 8b13789..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask/ext/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask_baz/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask_baz/__init__.py deleted file mode 100644 index e9b3fff..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask_baz/__init__.py +++ /dev/null @@ -1 +0,0 @@ -Baz = 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask_foo.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask_foo.py deleted file mode 100644 index 0b910b8..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flask_foo.py +++ /dev/null @@ -1,2 +0,0 @@ -class Foo(object): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/bar.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/bar.py deleted file mode 100644 index 6629f9a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/bar.py +++ /dev/null @@ -1,2 +0,0 @@ -class Bar(object): - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/moo/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/moo/__init__.py deleted file mode 100644 index 266e809..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/flask-site-packages/flaskext/moo/__init__.py +++ /dev/null @@ -1 +0,0 @@ -Moo = 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_namespace_package/ns1/pkg/ns1_file.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_namespace_package/ns1/pkg/ns1_file.py deleted file mode 100644 index 940279f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_namespace_package/ns1/pkg/ns1_file.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'ns1_file!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_namespace_package/ns2/pkg/ns2_file.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_namespace_package/ns2/pkg/ns2_file.py deleted file mode 100644 index e87d7d8..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_namespace_package/ns2/pkg/ns2_file.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'ns2_file!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_nested_namespaces/namespace/pkg/module.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_nested_namespaces/namespace/pkg/module.py deleted file mode 100644 index 3c37820..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/implicit_nested_namespaces/namespace/pkg/module.py +++ /dev/null @@ -1 +0,0 @@ -CONST = 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/__init__.cpython-34m.so b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/__init__.cpython-34m.so deleted file mode 100644 index abfadc3..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/__init__.cpython-34m.so and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/module.c b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/module.c deleted file mode 100644 index bfa06f6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/module.c +++ /dev/null @@ -1,15 +0,0 @@ -#include "Python.h" - -static struct PyModuleDef module = { - PyModuleDef_HEAD_INIT, - "init_extension_module", - NULL, - -1, - NULL -}; - -PyMODINIT_FUNC PyInit_init_extension_module(void){ - PyObject *m = PyModule_Create(&module); - PyModule_AddObject(m, "foo", Py_None); - return m; -} diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/setup.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/setup.py deleted file mode 100644 index 5ce0517..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/init_extension_module/setup.py +++ /dev/null @@ -1,10 +0,0 @@ -from distutils.core import setup, Extension - -setup(name='init_extension_module', - version='0.0', - description='', - ext_modules=[ - Extension('init_extension_module.__init__', - sources=['module.c']) - ] -) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/__init__.py deleted file mode 100644 index bc10ee2..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -foo = 'ns1!' - -# this is a namespace package -try: - import pkg_resources - pkg_resources.declare_namespace(__name__) -except ImportError: - import pkgutil - __path__ = pkgutil.extend_path(__path__, __name__) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/ns1_file.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/ns1_file.py deleted file mode 100644 index 940279f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/ns1_file.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'ns1_file!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/ns1_folder/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/ns1_folder/__init__.py deleted file mode 100644 index 9eeeb29..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns1/pkg/ns1_folder/__init__.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'ns1_folder!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_file.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_file.py deleted file mode 100644 index e87d7d8..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_file.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'ns2_file!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/__init__.py deleted file mode 100644 index 70b24ae..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/__init__.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'ns2_folder!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/nested/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/nested/__init__.py deleted file mode 100644 index fbba1db..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/namespace_package/ns2/pkg/ns2_folder/nested/__init__.py +++ /dev/null @@ -1 +0,0 @@ -foo = 'nested!' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/namespace/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/namespace/__init__.py deleted file mode 100644 index 42e33a7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/namespace/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -try: - __import__('pkg_resources').declare_namespace(__name__) -except ImportError: - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/namespace/pkg/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/namespace/pkg/__init__.py deleted file mode 100644 index 3c37820..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/nested_namespaces/namespace/pkg/__init__.py +++ /dev/null @@ -1 +0,0 @@ -CONST = 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path.py deleted file mode 100644 index 8943d8d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path.py +++ /dev/null @@ -1 +0,0 @@ -value = 3 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path_package/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path_package/__init__.py deleted file mode 100644 index 5ef1a74..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path_package/__init__.py +++ /dev/null @@ -1 +0,0 @@ -value = 'package' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path_package/module.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path_package/module.py deleted file mode 100644 index 364dd03..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/not_in_sys_path_package/module.py +++ /dev/null @@ -1 +0,0 @@ -value = 'package.module' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/pkg/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/pkg/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/pkg/module.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/pkg/module.py deleted file mode 100644 index 53c44ca..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/not_in_sys_path/pkg/module.py +++ /dev/null @@ -1,7 +0,0 @@ -from not_in_sys_path import not_in_sys_path -from not_in_sys_path import not_in_sys_path_package -from not_in_sys_path.not_in_sys_path_package import module - -not_in_sys_path.value -not_in_sys_path_package.value -module.value diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/dir-from-foo-pth/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/dir-from-foo-pth/__init__.py deleted file mode 100644 index 2a1d870..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/dir-from-foo-pth/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -# This file is here to force git to create the directory, as *.pth files only -# add existing directories. diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/egg_link.egg-link b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/egg_link.egg-link deleted file mode 100644 index dde9b7d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/egg_link.egg-link +++ /dev/null @@ -1 +0,0 @@ -/path/from/egg-link diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/foo.pth b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/foo.pth deleted file mode 100644 index 8850168..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/foo.pth +++ /dev/null @@ -1 +0,0 @@ -./dir-from-foo-pth diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/import_smth.pth b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/import_smth.pth deleted file mode 100644 index 72b006a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/import_smth.pth +++ /dev/null @@ -1 +0,0 @@ -import smth; smth.extend_path() \ No newline at end of file diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/relative.egg-link b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/relative.egg-link deleted file mode 100644 index 7a9a615..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/relative.egg-link +++ /dev/null @@ -1 +0,0 @@ -./relative/egg-link/path diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/smth.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/smth.py deleted file mode 100644 index 3e3008d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv27/lib/python2.7/site-packages/smth.py +++ /dev/null @@ -1,6 +0,0 @@ -import sys -sys.path.append('/path/from/smth.py') - - -def extend_path(): - sys.path.append('/path/from/smth.py:extend_path') diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/dir-from-foo-pth/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/dir-from-foo-pth/__init__.py deleted file mode 100644 index 2a1d870..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/dir-from-foo-pth/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -# This file is here to force git to create the directory, as *.pth files only -# add existing directories. diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/egg_link.egg-link b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/egg_link.egg-link deleted file mode 100644 index dde9b7d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/egg_link.egg-link +++ /dev/null @@ -1 +0,0 @@ -/path/from/egg-link diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/foo.pth b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/foo.pth deleted file mode 100644 index 8850168..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/foo.pth +++ /dev/null @@ -1 +0,0 @@ -./dir-from-foo-pth diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/import_smth.pth b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/import_smth.pth deleted file mode 100644 index 72b006a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/import_smth.pth +++ /dev/null @@ -1 +0,0 @@ -import smth; smth.extend_path() \ No newline at end of file diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/relative.egg-link b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/relative.egg-link deleted file mode 100644 index 7a9a615..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/relative.egg-link +++ /dev/null @@ -1 +0,0 @@ -./relative/egg-link/path diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/smth.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/smth.py deleted file mode 100644 index 3e3008d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/sample_venvs/venv34/lib/python3.4/site-packages/smth.py +++ /dev/null @@ -1,6 +0,0 @@ -import sys -sys.path.append('/path/from/smth.py') - - -def extend_path(): - sys.path.append('/path/from/smth.py:extend_path') diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_absolute_import.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_absolute_import.py deleted file mode 100644 index 418cd56..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_absolute_import.py +++ /dev/null @@ -1,12 +0,0 @@ -""" -Tests ``from __future__ import absolute_import`` (only important for -Python 2.X) -""" -import jedi -from .. import helpers - - -@helpers.cwd_at("test/test_evaluate/absolute_import") -def test_can_complete_when_shadowing(): - script = jedi.Script(path="unittest.py") - assert script.completions() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_annotations.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_annotations.py deleted file mode 100644 index 67fe84e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_annotations.py +++ /dev/null @@ -1,60 +0,0 @@ -from textwrap import dedent - -import jedi -import pytest - - -@pytest.mark.skipif('sys.version_info[0] < 3') -def test_simple_annotations(): - """ - Annotations only exist in Python 3. - If annotations adhere to PEP-0484, we use them (they override inference), - else they are parsed but ignored - """ - - source = dedent("""\ - def annot(a:3): - return a - - annot('')""") - - assert [d.name for d in jedi.Script(source, ).goto_definitions()] == ['str'] - - source = dedent("""\ - - def annot_ret(a:3) -> 3: - return a - - annot_ret('')""") - assert [d.name for d in jedi.Script(source, ).goto_definitions()] == ['str'] - - source = dedent("""\ - def annot(a:int): - return a - - annot('')""") - - assert [d.name for d in jedi.Script(source, ).goto_definitions()] == ['int'] - - -@pytest.mark.skipif('sys.version_info[0] < 3') -@pytest.mark.parametrize('reference', [ - 'assert 1', - '1', - 'def x(): pass', - '1, 2', - r'1\n' -]) -def test_illegal_forward_references(reference): - source = 'def foo(bar: "%s"): bar' % reference - - assert not jedi.Script(source).goto_definitions() - - -@pytest.mark.skipif('sys.version_info[0] < 3') -def test_lambda_forward_references(): - source = 'def foo(bar: "lambda: 3"): bar' - - # For now just receiving the 3 is ok. I'm doubting that this is what we - # want. We also execute functions. Should we only execute classes? - assert jedi.Script(source).goto_definitions() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_buildout_detection.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_buildout_detection.py deleted file mode 100644 index bb65201..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_buildout_detection.py +++ /dev/null @@ -1,90 +0,0 @@ -import os -from textwrap import dedent - -from jedi import Script -from jedi.evaluate.sys_path import (_get_parent_dir_with_file, - _get_buildout_script_paths, - check_sys_path_modifications) - -from ..helpers import cwd_at - - -def check_module_test(code): - module_context = Script(code)._get_module() - return check_sys_path_modifications(module_context) - - -@cwd_at('test/test_evaluate/buildout_project/src/proj_name') -def test_parent_dir_with_file(): - parent = _get_parent_dir_with_file( - os.path.abspath(os.curdir), 'buildout.cfg') - assert parent is not None - assert parent.endswith(os.path.join('test', 'test_evaluate', 'buildout_project')) - - -@cwd_at('test/test_evaluate/buildout_project/src/proj_name') -def test_buildout_detection(): - scripts = _get_buildout_script_paths(os.path.abspath('./module_name.py')) - assert len(scripts) == 1 - curdir = os.path.abspath(os.curdir) - appdir_path = os.path.normpath(os.path.join(curdir, '../../bin/app')) - assert scripts[0] == appdir_path - - -def test_append_on_non_sys_path(): - code = dedent(""" - class Dummy(object): - path = [] - - d = Dummy() - d.path.append('foo')""" - ) - - paths = check_module_test(code) - assert not paths - assert 'foo' not in paths - - -def test_path_from_invalid_sys_path_assignment(): - code = dedent(""" - import sys - sys.path = 'invalid'""" - ) - - paths = check_module_test(code) - assert not paths - assert 'invalid' not in paths - - -@cwd_at('test/test_evaluate/buildout_project/src/proj_name/') -def test_sys_path_with_modifications(): - code = dedent(""" - import os - """) - - path = os.path.abspath(os.path.join(os.curdir, 'module_name.py')) - paths = Script(code, path=path)._evaluator.project.sys_path - assert '/tmp/.buildout/eggs/important_package.egg' in paths - - -def test_path_from_sys_path_assignment(): - code = dedent(""" - #!/usr/bin/python - - import sys - sys.path[0:0] = [ - '/usr/lib/python3.4/site-packages', - '/home/test/.buildout/eggs/important_package.egg' - ] - - path[0:0] = [1] - - import important_package - - if __name__ == '__main__': - sys.exit(important_package.main())""" - ) - - paths = check_module_test(code) - assert 1 not in paths - assert '/home/test/.buildout/eggs/important_package.egg' in paths diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_compiled.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_compiled.py deleted file mode 100644 index 44aef93..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_compiled.py +++ /dev/null @@ -1,100 +0,0 @@ -from textwrap import dedent - -import parso - -from jedi._compatibility import builtins, is_py3 -from jedi.evaluate import compiled -from jedi.evaluate.context import instance -from jedi.evaluate.context.function import FunctionContext -from jedi.evaluate import Evaluator -from jedi.evaluate.project import Project -from jedi.parser_utils import clean_scope_docstring -from jedi import Script - - -def _evaluator(): - return Evaluator(parso.load_grammar(), Project()) - - -def test_simple(): - e = _evaluator() - bltn = compiled.CompiledObject(e, builtins) - obj = compiled.CompiledObject(e, '_str_', bltn) - upper, = obj.py__getattribute__('upper') - objs = list(upper.execute_evaluated()) - assert len(objs) == 1 - assert isinstance(objs[0], instance.CompiledInstance) - - -def test_fake_loading(): - e = _evaluator() - assert isinstance(compiled.create(e, next), FunctionContext) - - builtin = compiled.get_special_object(e, 'BUILTINS') - string, = builtin.py__getattribute__('str') - from_name = compiled._create_from_name(e, builtin, string, '__init__') - assert isinstance(from_name, FunctionContext) - - -def test_fake_docstr(): - node = compiled.create(_evaluator(), next).tree_node - assert clean_scope_docstring(node) == next.__doc__ - - -def test_parse_function_doc_illegal_docstr(): - docstr = """ - test_func(o - - doesn't have a closing bracket. - """ - assert ('', '') == compiled._parse_function_doc(docstr) - - -def test_doc(): - """ - Even CompiledObject docs always return empty docstrings - not None, that's - just a Jedi API definition. - """ - obj = compiled.CompiledObject(_evaluator(), ''.__getnewargs__) - assert obj.py__doc__() == '' - - -def test_string_literals(): - def typ(string): - d = Script("a = %s; a" % string).goto_definitions()[0] - return d.name - - assert typ('""') == 'str' - assert typ('r""') == 'str' - if is_py3: - assert typ('br""') == 'bytes' - assert typ('b""') == 'bytes' - assert typ('u""') == 'str' - else: - assert typ('b""') == 'str' - assert typ('u""') == 'unicode' - - -def test_method_completion(): - code = dedent(''' - class Foo: - def bar(self): - pass - - foo = Foo() - foo.bar.__func__''') - if is_py3: - result = [] - else: - result = ['__func__'] - assert [c.name for c in Script(code).completions()] == result - - -def test_time_docstring(): - import time - comp, = Script('import time\ntime.sleep').completions() - assert comp.docstring() == time.sleep.__doc__ - - -def test_dict_values(): - assert Script('import sys\nsys.modules["alshdb;lasdhf"]').goto_definitions() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_context.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_context.py deleted file mode 100644 index 178b879..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_context.py +++ /dev/null @@ -1,10 +0,0 @@ -from jedi import Script - - -def test_module_attributes(): - def_, = Script('__name__').completions() - assert def_.name == '__name__' - assert def_.line == None - assert def_.column == None - str_, = def_._goto_definitions() - assert str_.name == 'str' diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_docstring.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_docstring.py deleted file mode 100644 index b1676ab..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_docstring.py +++ /dev/null @@ -1,331 +0,0 @@ -""" -Testing of docstring related issues and especially ``jedi.docstrings``. -""" - -from textwrap import dedent -import jedi -import pytest -from ..helpers import unittest - -try: - import numpydoc # NOQA -except ImportError: - numpydoc_unavailable = True -else: - numpydoc_unavailable = False - -try: - import numpy -except ImportError: - numpy_unavailable = True -else: - numpy_unavailable = False - - -class TestDocstring(unittest.TestCase): - def test_function_doc(self): - defs = jedi.Script(""" - def func(): - '''Docstring of `func`.''' - func""").goto_definitions() - self.assertEqual(defs[0].docstring(), 'func()\n\nDocstring of `func`.') - - def test_class_doc(self): - defs = jedi.Script(""" - class TestClass(): - '''Docstring of `TestClass`.''' - TestClass""").goto_definitions() - self.assertEqual(defs[0].docstring(), 'Docstring of `TestClass`.') - - def test_instance_doc(self): - defs = jedi.Script(""" - class TestClass(): - '''Docstring of `TestClass`.''' - tc = TestClass() - tc""").goto_definitions() - self.assertEqual(defs[0].docstring(), 'Docstring of `TestClass`.') - - @unittest.skip('need evaluator class for that') - def test_attribute_docstring(self): - defs = jedi.Script(""" - x = None - '''Docstring of `x`.''' - x""").goto_definitions() - self.assertEqual(defs[0].docstring(), 'Docstring of `x`.') - - @unittest.skip('need evaluator class for that') - def test_multiple_docstrings(self): - defs = jedi.Script(""" - def func(): - '''Original docstring.''' - x = func - '''Docstring of `x`.''' - x""").goto_definitions() - docs = [d.docstring() for d in defs] - self.assertEqual(docs, ['Original docstring.', 'Docstring of `x`.']) - - def test_completion(self): - assert jedi.Script(''' - class DocstringCompletion(): - #? [] - """ asdfas """''').completions() - - def test_docstrings_type_dotted_import(self): - s = """ - def func(arg): - ''' - :type arg: random.Random - ''' - arg.""" - names = [c.name for c in jedi.Script(s).completions()] - assert 'seed' in names - - def test_docstrings_param_type(self): - s = """ - def func(arg): - ''' - :param str arg: some description - ''' - arg.""" - names = [c.name for c in jedi.Script(s).completions()] - assert 'join' in names - - def test_docstrings_type_str(self): - s = """ - def func(arg): - ''' - :type arg: str - ''' - arg.""" - - names = [c.name for c in jedi.Script(s).completions()] - assert 'join' in names - - def test_docstring_instance(self): - # The types hint that it's a certain kind - s = dedent(""" - class A: - def __init__(self,a): - ''' - :type a: threading.Thread - ''' - - if a is not None: - a.start() - - self.a = a - - - def method_b(c): - ''' - :type c: A - ''' - - c.""") - - names = [c.name for c in jedi.Script(s).completions()] - assert 'a' in names - assert '__init__' in names - assert 'mro' not in names # Exists only for types. - - def test_docstring_keyword(self): - completions = jedi.Script('assert').completions() - self.assertIn('assert', completions[0].docstring()) - -# ---- Numpy Style Tests --- - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_parameters(): - s = dedent(''' - def foobar(x, y): - """ - Parameters - ---------- - x : int - y : str - """ - y.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'isupper' in names - assert 'capitalize' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_parameters_set_of_values(): - s = dedent(''' - def foobar(x, y): - """ - Parameters - ---------- - x : {'foo', 'bar', 100500}, optional - """ - x.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'isupper' in names - assert 'capitalize' in names - assert 'numerator' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_parameters_alternative_types(): - s = dedent(''' - def foobar(x, y): - """ - Parameters - ---------- - x : int or str or list - """ - x.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'isupper' in names - assert 'capitalize' in names - assert 'numerator' in names - assert 'append' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_returns(): - s = dedent(''' - def foobar(): - """ - Returns - ---------- - x : int - y : str - """ - return x - - def bazbiz(): - z = foobar() - z.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'isupper' in names - assert 'capitalize' in names - assert 'numerator' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_returns_set_of_values(): - s = dedent(''' - def foobar(): - """ - Returns - ---------- - x : {'foo', 'bar', 100500} - """ - return x - - def bazbiz(): - z = foobar() - z.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'isupper' in names - assert 'capitalize' in names - assert 'numerator' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_returns_alternative_types(): - s = dedent(''' - def foobar(): - """ - Returns - ---------- - int or list of str - """ - return x - - def bazbiz(): - z = foobar() - z.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'isupper' not in names - assert 'capitalize' not in names - assert 'numerator' in names - assert 'append' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_returns_list_of(): - s = dedent(''' - def foobar(): - """ - Returns - ---------- - list of str - """ - return x - - def bazbiz(): - z = foobar() - z.''') - names = [c.name for c in jedi.Script(s).completions()] - assert 'append' in names - assert 'isupper' not in names - assert 'capitalize' not in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_returns_obj(): - s = dedent(''' - def foobar(x, y): - """ - Returns - ---------- - int or random.Random - """ - return x + y - - def bazbiz(): - z = foobar(x, y) - z.''') - script = jedi.Script(s) - names = [c.name for c in script.completions()] - assert 'numerator' in names - assert 'seed' in names - -@pytest.mark.skipif(numpydoc_unavailable, - reason='numpydoc module is unavailable') -def test_numpydoc_yields(): - s = dedent(''' - def foobar(): - """ - Yields - ---------- - x : int - y : str - """ - return x - - def bazbiz(): - z = foobar(): - z.''') - names = [c.name for c in jedi.Script(s).completions()] - print('names',names) - assert 'isupper' in names - assert 'capitalize' in names - assert 'numerator' in names - -@pytest.mark.skipif(numpydoc_unavailable or numpy_unavailable, - reason='numpydoc or numpy module is unavailable') -def test_numpy_returns(): - s = dedent(''' - import numpy - x = numpy.asarray([]) - x.d''') - names = [c.name for c in jedi.Script(s).completions()] - print(names) - assert 'diagonal' in names - -@pytest.mark.skipif(numpydoc_unavailable or numpy_unavailable, - reason='numpydoc or numpy module is unavailable') -def test_numpy_comp_returns(): - s = dedent(''' - import numpy - x = numpy.array([]) - x.d''') - names = [c.name for c in jedi.Script(s).completions()] - print(names) - assert 'diagonal' in names - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_extension.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_extension.py deleted file mode 100644 index 83efc20..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_extension.py +++ /dev/null @@ -1,57 +0,0 @@ -""" -Test compiled module -""" -import os - -import jedi -from ..helpers import cwd_at -import pytest - - -def test_completions(): - s = jedi.Script('import _ctypes; _ctypes.') - assert len(s.completions()) >= 15 - - -def test_call_signatures_extension(): - if os.name == 'nt': - func = 'LoadLibrary' - params = 1 - else: - func = 'dlopen' - params = 2 - s = jedi.Script('import _ctypes; _ctypes.%s(' % (func,)) - sigs = s.call_signatures() - assert len(sigs) == 1 - assert len(sigs[0].params) == params - - -def test_call_signatures_stdlib(): - s = jedi.Script('import math; math.cos(') - sigs = s.call_signatures() - assert len(sigs) == 1 - assert len(sigs[0].params) == 1 - - -# Check only on linux 64 bit platform and Python3.4. -@pytest.mark.skipif('sys.platform != "linux" or sys.maxsize <= 2**32 or sys.version_info[:2] != (3, 4)') -@cwd_at('test/test_evaluate') -def test_init_extension_module(): - """ - ``__init__`` extension modules are also packages and Jedi should understand - that. - - Originally coming from #472. - - This test was built by the module.c and setup.py combination you can find - in the init_extension_module folder. You can easily build the - `__init__.cpython-34m.so` by compiling it (create a virtualenv and run - `setup.py install`. - - This is also why this test only runs on certain systems (and Python 3.4). - """ - s = jedi.Script('import init_extension_module as i\ni.', path='not_existing.py') - assert 'foo' in [c.name for c in s.completions()] - - s = jedi.Script('from init_extension_module import foo\nfoo', path='not_existing.py') - assert ['foo'] == [c.name for c in s.completions()] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_helpers.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_helpers.py deleted file mode 100644 index 4484c2b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_helpers.py +++ /dev/null @@ -1,16 +0,0 @@ -from textwrap import dedent - -from jedi import names -from jedi.evaluate import helpers - - -def test_call_of_leaf_in_brackets(): - s = dedent(""" - x = 1 - type(x) - """) - last_x = names(s, references=True, definitions=False)[-1] - name = last_x._name.tree_name - - call = helpers.call_of_leaf(name) - assert call == name diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_implicit_namespace_package.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_implicit_namespace_package.py deleted file mode 100644 index 9bc9098..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_implicit_namespace_package.py +++ /dev/null @@ -1,58 +0,0 @@ -from os.path import dirname, join - -import jedi -import pytest - - -@pytest.mark.skipif('sys.version_info[:2] < (3,4)') -def test_implicit_namespace_package(): - sys_path = [join(dirname(__file__), d) - for d in ['implicit_namespace_package/ns1', 'implicit_namespace_package/ns2']] - - def script_with_path(*args, **kwargs): - return jedi.Script(sys_path=sys_path, *args, **kwargs) - - # goto definition - assert script_with_path('from pkg import ns1_file').goto_definitions() - assert script_with_path('from pkg import ns2_file').goto_definitions() - assert not script_with_path('from pkg import ns3_file').goto_definitions() - - # goto assignment - tests = { - 'from pkg.ns2_file import foo': 'ns2_file!', - 'from pkg.ns1_file import foo': 'ns1_file!', - } - for source, solution in tests.items(): - ass = script_with_path(source).goto_assignments() - assert len(ass) == 1 - assert ass[0].description == "foo = '%s'" % solution - - # completion - completions = script_with_path('from pkg import ').completions() - names = [c.name for c in completions] - compare = ['ns1_file', 'ns2_file'] - # must at least contain these items, other items are not important - assert set(compare) == set(names) - - tests = { - 'from pkg import ns2_file as x': 'ns2_file!', - 'from pkg import ns1_file as x': 'ns1_file!' - } - for source, solution in tests.items(): - for c in script_with_path(source + '; x.').completions(): - if c.name == 'foo': - completion = c - solution = "foo = '%s'" % solution - assert completion.description == solution - -@pytest.mark.skipif('sys.version_info[:2] < (3,4)') -def test_implicit_nested_namespace_package(): - CODE = 'from implicit_nested_namespaces.namespace.pkg.module import CONST' - - sys_path = [dirname(__file__)] - - script = jedi.Script(sys_path=sys_path, source=CODE, line=1, column=61) - - result = script.goto_definitions() - - assert len(result) == 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_imports.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_imports.py deleted file mode 100644 index a41d4f0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_imports.py +++ /dev/null @@ -1,237 +0,0 @@ -""" -Tests of various import related things that could not be tested with "Black Box -Tests". -""" - -import os -import sys - -import pytest - -import jedi -from jedi._compatibility import find_module_py33, find_module -from ..helpers import cwd_at - -from jedi import Script -from jedi._compatibility import is_py26 - - -@pytest.mark.skipif('sys.version_info < (3,3)') -def test_find_module_py33(): - """Needs to work like the old find_module.""" - assert find_module_py33('_io') == (None, '_io', False) - - -def test_find_module_package(): - file, path, is_package = find_module('json') - assert file is None - assert path.endswith('json') - assert is_package is True - - -def test_find_module_not_package(): - file, path, is_package = find_module('io') - assert file is not None - assert path.endswith('io.py') - assert is_package is False - - -def test_find_module_package_zipped(): - if 'zipped_imports/pkg.zip' not in sys.path: - sys.path.append(os.path.join(os.path.dirname(__file__), - 'zipped_imports/pkg.zip')) - file, path, is_package = find_module('pkg') - assert file is not None - assert path.endswith('pkg.zip') - assert is_package is True - assert len(jedi.Script('import pkg; pkg.mod', 1, 19).completions()) == 1 - - -@pytest.mark.skipif('sys.version_info < (2,7)') -def test_find_module_not_package_zipped(): - if 'zipped_imports/not_pkg.zip' not in sys.path: - sys.path.append(os.path.join(os.path.dirname(__file__), - 'zipped_imports/not_pkg.zip')) - file, path, is_package = find_module('not_pkg') - assert file is not None - assert path.endswith('not_pkg.zip') - assert is_package is False - assert len( - jedi.Script('import not_pkg; not_pkg.val', 1, 27).completions()) == 1 - - -@cwd_at('test/test_evaluate/not_in_sys_path/pkg') -def test_import_not_in_sys_path(): - """ - non-direct imports (not in sys.path) - """ - a = jedi.Script(path='module.py', line=5).goto_definitions() - assert a[0].name == 'int' - - a = jedi.Script(path='module.py', line=6).goto_definitions() - assert a[0].name == 'str' - a = jedi.Script(path='module.py', line=7).goto_definitions() - assert a[0].name == 'str' - - -@pytest.mark.parametrize("script,name", [ - ("from flask.ext import foo; foo.", "Foo"), # flask_foo.py - ("from flask.ext import bar; bar.", "Bar"), # flaskext/bar.py - ("from flask.ext import baz; baz.", "Baz"), # flask_baz/__init__.py - ("from flask.ext import moo; moo.", "Moo"), # flaskext/moo/__init__.py - ("from flask.ext.", "foo"), - ("from flask.ext.", "bar"), - ("from flask.ext.", "baz"), - ("from flask.ext.", "moo"), - pytest.mark.xfail(("import flask.ext.foo; flask.ext.foo.", "Foo")), - pytest.mark.xfail(("import flask.ext.bar; flask.ext.bar.", "Foo")), - pytest.mark.xfail(("import flask.ext.baz; flask.ext.baz.", "Foo")), - pytest.mark.xfail(("import flask.ext.moo; flask.ext.moo.", "Foo")), -]) -def test_flask_ext(script, name): - """flask.ext.foo is really imported from flaskext.foo or flask_foo. - """ - path = os.path.join(os.path.dirname(__file__), 'flask-site-packages') - completions = jedi.Script(script, sys_path=[path]).completions() - assert name in [c.name for c in completions] - - -@cwd_at('test/test_evaluate/') -def test_not_importable_file(): - src = 'import not_importable_file as x; x.' - assert not jedi.Script(src, path='example.py').completions() - - -def test_import_unique(): - src = "import os; os.path" - defs = jedi.Script(src, path='example.py').goto_definitions() - parent_contexts = [d._name._context for d in defs] - assert len(parent_contexts) == len(set(parent_contexts)) - - -def test_cache_works_with_sys_path_param(tmpdir): - foo_path = tmpdir.join('foo') - bar_path = tmpdir.join('bar') - foo_path.join('module.py').write('foo = 123', ensure=True) - bar_path.join('module.py').write('bar = 123', ensure=True) - foo_completions = jedi.Script('import module; module.', - sys_path=[foo_path.strpath]).completions() - bar_completions = jedi.Script('import module; module.', - sys_path=[bar_path.strpath]).completions() - assert 'foo' in [c.name for c in foo_completions] - assert 'bar' not in [c.name for c in foo_completions] - - assert 'bar' in [c.name for c in bar_completions] - assert 'foo' not in [c.name for c in bar_completions] - - -def test_import_completion_docstring(): - import abc - s = jedi.Script('"""test"""\nimport ab') - completions = s.completions() - assert len(completions) == 1 - assert completions[0].docstring(fast=False) == abc.__doc__ - - # However for performance reasons not all modules are loaded and the - # docstring is empty in this case. - assert completions[0].docstring() == '' - - -def test_goto_definition_on_import(): - assert Script("import sys_blabla", 1, 8).goto_definitions() == [] - assert len(Script("import sys", 1, 8).goto_definitions()) == 1 - - -@cwd_at('jedi') -def test_complete_on_empty_import(): - assert Script("from datetime import").completions()[0].name == 'import' - # should just list the files in the directory - assert 10 < len(Script("from .", path='whatever.py').completions()) < 30 - - # Global import - assert len(Script("from . import", 1, 5, 'whatever.py').completions()) > 30 - # relative import - assert 10 < len(Script("from . import", 1, 6, 'whatever.py').completions()) < 30 - - # Global import - assert len(Script("from . import classes", 1, 5, 'whatever.py').completions()) > 30 - # relative import - assert 10 < len(Script("from . import classes", 1, 6, 'whatever.py').completions()) < 30 - - wanted = set(['ImportError', 'import', 'ImportWarning']) - assert set([c.name for c in Script("import").completions()]) == wanted - if not is_py26: # python 2.6 doesn't always come with a library `import*`. - assert len(Script("import import", path='').completions()) > 0 - - # 111 - assert Script("from datetime import").completions()[0].name == 'import' - assert Script("from datetime import ").completions() - - -def test_imports_on_global_namespace_without_path(): - """If the path is None, there shouldn't be any import problem""" - completions = Script("import operator").completions() - assert [c.name for c in completions] == ['operator'] - completions = Script("import operator", path='example.py').completions() - assert [c.name for c in completions] == ['operator'] - - # the first one has a path the second doesn't - completions = Script("import keyword", path='example.py').completions() - assert [c.name for c in completions] == ['keyword'] - completions = Script("import keyword").completions() - assert [c.name for c in completions] == ['keyword'] - - -def test_named_import(): - """named import - jedi-vim issue #8""" - s = "import time as dt" - assert len(Script(s, 1, 15, '/').goto_definitions()) == 1 - assert len(Script(s, 1, 10, '/').goto_definitions()) == 1 - - -@pytest.mark.skipif('True', reason='The nested import stuff is still very messy.') -def test_goto_following_on_imports(): - s = "import multiprocessing.dummy; multiprocessing.dummy" - g = Script(s).goto_assignments() - assert len(g) == 1 - assert (g[0].line, g[0].column) != (0, 0) - - -def test_os_after_from(): - def check(source, result, column=None): - completions = Script(source, column=column).completions() - assert [c.name for c in completions] == result - - check('\nfrom os. ', ['path']) - check('\nfrom os ', ['import']) - check('from os ', ['import']) - check('\nfrom os import whatever', ['import'], len('from os im')) - - check('from os\\\n', ['import']) - check('from os \\\n', ['import']) - - -def test_os_issues(): - def import_names(*args, **kwargs): - return [d.name for d in jedi.Script(*args, **kwargs).completions()] - - # Github issue #759 - s = 'import os, s' - assert 'sys' in import_names(s) - assert 'path' not in import_names(s, column=len(s) - 1) - assert 'os' in import_names(s, column=len(s) - 3) - - # Some more checks - s = 'from os import path, e' - assert 'environ' in import_names(s) - assert 'json' not in import_names(s, column=len(s) - 1) - assert 'environ' in import_names(s, column=len(s) - 1) - assert 'path' in import_names(s, column=len(s) - 3) - - -def test_path_issues(): - """ - See pull request #684 for details. - """ - source = '''from datetime import ''' - assert jedi.Script(source).completions() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_literals.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_literals.py deleted file mode 100644 index 403020a..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_literals.py +++ /dev/null @@ -1,41 +0,0 @@ -import pytest - -import jedi -from jedi._compatibility import py_version, unicode - - -def _eval_literal(code): - def_, = jedi.Script(code).goto_definitions() - return def_._name._context.obj - - -@pytest.mark.skipif('sys.version_info[:2] < (3, 6)') -def test_f_strings(): - """ - f literals are not really supported in Jedi. They just get ignored and an - empty string is returned. - """ - assert _eval_literal('f"asdf"') == '' - assert _eval_literal('f"{asdf}"') == '' - assert _eval_literal('F"{asdf}"') == '' - assert _eval_literal('rF"{asdf}"') == '' - - -def test_rb_strings(): - assert _eval_literal('br"asdf"') == b'asdf' - obj = _eval_literal('rb"asdf"') - if py_version < 33: - # rb is not valid in Python 2. Due to error recovery we just get a - # string. - assert obj == 'asdf' - else: - assert obj == b'asdf' - - -@pytest.mark.skipif('sys.version_info[:2] < (3, 6)') -def test_thousand_separators(): - assert _eval_literal('1_2_3') == 123 - assert _eval_literal('123_456_789') == 123456789 - assert _eval_literal('0x3_4') == 52 - assert _eval_literal('0b1_0') == 2 - assert _eval_literal('0o1_0') == 8 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_mixed.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_mixed.py deleted file mode 100644 index 5940fe6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_mixed.py +++ /dev/null @@ -1,7 +0,0 @@ -import jedi - - -def test_on_code(): - from functools import wraps - i = jedi.Interpreter("wraps.__code__", [{'wraps':wraps}]) - assert i.goto_definitions() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_namespace_package.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_namespace_package.py deleted file mode 100644 index 9d3aeb7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_namespace_package.py +++ /dev/null @@ -1,65 +0,0 @@ -import jedi -from os.path import dirname, join - - -def test_namespace_package(): - sys_path = [join(dirname(__file__), d) - for d in ['namespace_package/ns1', 'namespace_package/ns2']] - - def script_with_path(*args, **kwargs): - return jedi.Script(sys_path=sys_path, *args, **kwargs) - - # goto definition - assert script_with_path('from pkg import ns1_file').goto_definitions() - assert script_with_path('from pkg import ns2_file').goto_definitions() - assert not script_with_path('from pkg import ns3_file').goto_definitions() - - # goto assignment - tests = { - 'from pkg.ns2_folder.nested import foo': 'nested!', - 'from pkg.ns2_folder import foo': 'ns2_folder!', - 'from pkg.ns2_file import foo': 'ns2_file!', - 'from pkg.ns1_folder import foo': 'ns1_folder!', - 'from pkg.ns1_file import foo': 'ns1_file!', - 'from pkg import foo': 'ns1!', - } - for source, solution in tests.items(): - ass = script_with_path(source).goto_assignments() - assert len(ass) == 1 - assert ass[0].description == "foo = '%s'" % solution - - # completion - completions = script_with_path('from pkg import ').completions() - names = [str(c.name) for c in completions] # str because of unicode - compare = ['foo', 'ns1_file', 'ns1_folder', 'ns2_folder', 'ns2_file', - 'pkg_resources', 'pkgutil', '__name__', '__path__', - '__package__', '__file__', '__doc__'] - # must at least contain these items, other items are not important - assert set(compare) == set(names) - - tests = { - 'from pkg import ns2_folder as x': 'ns2_folder!', - 'from pkg import ns2_file as x': 'ns2_file!', - 'from pkg.ns2_folder import nested as x': 'nested!', - 'from pkg import ns1_folder as x': 'ns1_folder!', - 'from pkg import ns1_file as x': 'ns1_file!', - 'import pkg as x': 'ns1!', - } - for source, solution in tests.items(): - for c in script_with_path(source + '; x.').completions(): - if c.name == 'foo': - completion = c - solution = "foo = '%s'" % solution - assert completion.description == solution - - -def test_nested_namespace_package(): - code = 'from nested_namespaces.namespace.pkg import CONST' - - sys_path = [dirname(__file__)] - - script = jedi.Script(sys_path=sys_path, source=code, line=1, column=45) - - result = script.goto_definitions() - - assert len(result) == 1 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_precedence.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_precedence.py deleted file mode 100644 index f5e0770..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_precedence.py +++ /dev/null @@ -1,17 +0,0 @@ -from jedi.evaluate.compiled import CompiledObject -from jedi import Script - -import pytest - - -@pytest.mark.skipif('sys.version_info[0] < 3') # Ellipsis does not exists in 2 -@pytest.mark.parametrize('source', [ - '1 == 1', - '1.0 == 1', - '... == ...' -]) -def test_equals(source): - script = Script(source) - node = script._get_module_node().children[0] - first, = script._get_module().eval_node(node) - assert isinstance(first, CompiledObject) and first.obj is True diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_pyc.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_pyc.py deleted file mode 100644 index c101da1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_pyc.py +++ /dev/null @@ -1,64 +0,0 @@ -""" -Test completions from *.pyc files: - - - generate a dummy python module - - compile the dummy module to generate a *.pyc - - delete the pure python dummy module - - try jedi on the generated *.pyc -""" -import os -import shutil -import sys - -import pytest - -import jedi -from ..helpers import cwd_at - - -SRC = """class Foo: - pass - -class Bar: - pass -""" - - -def generate_pyc(): - os.mkdir("dummy_package") - with open("dummy_package/__init__.py", 'w'): - pass - with open("dummy_package/dummy.py", 'w') as f: - f.write(SRC) - import compileall - compileall.compile_file("dummy_package/dummy.py") - os.remove("dummy_package/dummy.py") - - if sys.version_info[0] == 3: - # Python3 specific: - # To import pyc modules, we must move them out of the __pycache__ - # directory and rename them to remove ".cpython-%s%d" - # see: http://stackoverflow.com/questions/11648440/python-does-not-detect-pyc-files - for f in os.listdir("dummy_package/__pycache__"): - dst = f.replace('.cpython-%s%s' % sys.version_info[:2], "") - dst = os.path.join("dummy_package", dst) - shutil.copy(os.path.join("dummy_package/__pycache__", f), dst) - - -# Python 2.6 does not necessarily come with `compileall.compile_file`. -@pytest.mark.skipif("sys.version_info > (2,6)") -@cwd_at('test/test_evaluate') -def test_pyc(): - """ - The list of completion must be greater than 2. - """ - try: - generate_pyc() - s = jedi.Script("from dummy_package import dummy; dummy.", path='blub.py') - assert len(s.completions()) >= 2 - finally: - shutil.rmtree("dummy_package") - - -if __name__ == "__main__": - test_pyc() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_representation.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_representation.py deleted file mode 100644 index 1323a9c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_representation.py +++ /dev/null @@ -1,36 +0,0 @@ -from textwrap import dedent - -from jedi import Script - - -def get_definition_and_evaluator(source): - first, = Script(dedent(source)).goto_definitions() - return first._name._context, first._evaluator - - -def test_function_execution(): - """ - We've been having an issue of a mutable list that was changed inside the - function execution. Test if an execution always returns the same result. - """ - - s = """ - def x(): - return str() - x""" - func, evaluator = get_definition_and_evaluator(s) - # Now just use the internals of the result (easiest way to get a fully - # usable function). - # Should return the same result both times. - assert len(func.execute_evaluated()) == 1 - assert len(func.execute_evaluated()) == 1 - - -def test_class_mro(): - s = """ - class X(object): - pass - X""" - cls, evaluator = get_definition_and_evaluator(s) - mro = cls.py__mro__() - assert [c.name.string_name for c in mro] == ['X', 'object'] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_stdlib.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_stdlib.py deleted file mode 100644 index 7347d84..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_stdlib.py +++ /dev/null @@ -1,77 +0,0 @@ -""" -Tests of various stdlib related things that could not be tested -with "Black Box Tests". -""" -from textwrap import dedent - -import pytest -from jedi import Script -from jedi._compatibility import is_py26 - -# The namedtuple is different for different Python2.7 versions. Some versions -# are missing the attribute `_class_template`. -pytestmark = pytest.mark.skipif('sys.version_info[0] < 3') - - -@pytest.mark.parametrize(['letter', 'expected'], [ - ('n', ['name']), - ('s', ['smart']), -]) -def test_namedtuple_str(letter, expected): - source = dedent("""\ - import collections - Person = collections.namedtuple('Person', 'name smart') - dave = Person('Dave', False) - dave.%s""") % letter - result = Script(source).completions() - completions = set(r.name for r in result) - if is_py26: - assert completions == set() - else: - assert completions == set(expected) - - -def test_namedtuple_list(): - source = dedent("""\ - import collections - Cat = collections.namedtuple('Person', ['legs', u'length', 'large']) - garfield = Cat(4, '85cm', True) - garfield.l""") - result = Script(source).completions() - completions = set(r.name for r in result) - if is_py26: - assert completions == set() - else: - assert completions == set(['legs', 'length', 'large']) - - -def test_namedtuple_content(): - source = dedent("""\ - import collections - Foo = collections.namedtuple('Foo', ['bar', 'baz']) - named = Foo(baz=4, bar=3.0) - unnamed = Foo(4, '') - """) - - def d(source): - x, = Script(source).goto_definitions() - return x.name - - assert d(source + 'unnamed.bar') == 'int' - assert d(source + 'unnamed.baz') == 'str' - assert d(source + 'named.bar') == 'float' - assert d(source + 'named.baz') == 'int' - - -def test_nested_namedtuples(): - """ - From issue #730. - """ - s = Script(dedent(''' - import collections - Dataset = collections.namedtuple('Dataset', ['data']) - Datasets = collections.namedtuple('Datasets', ['train']) - train_x = Datasets(train=Dataset('data_value')) - train_x.train.''' - )) - assert 'data' in [c.name for c in s.completions()] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_sys_path.py b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_sys_path.py deleted file mode 100644 index 7bedfa1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/test_sys_path.py +++ /dev/null @@ -1,58 +0,0 @@ -import os -from glob import glob -import sys - -import pytest - -from jedi.evaluate import sys_path -from jedi import Script - - -def test_paths_from_assignment(): - def paths(src): - script = Script(src, path='/foo/bar.py') - expr_stmt = script._get_module_node().children[0] - return set(sys_path._paths_from_assignment(script._get_module(), expr_stmt)) - - assert paths('sys.path[0:0] = ["a"]') == set(['/foo/a']) - assert paths('sys.path = ["b", 1, x + 3, y, "c"]') == set(['/foo/b', '/foo/c']) - assert paths('sys.path = a = ["a"]') == set(['/foo/a']) - - # Fail for complicated examples. - assert paths('sys.path, other = ["a"], 2') == set() - - -# Currently venv site-packages resolution only seeks pythonX.Y/site-packages -# that belong to the same version as the interpreter to avoid issues with -# cross-version imports. "venvs/" dir contains "venv27" and "venv34" that -# mimic venvs created for py2.7 and py3.4 respectively. If test runner is -# invoked with one of those versions, the test below will be run for the -# matching directory. -CUR_DIR = os.path.dirname(__file__) -VENVS = list(glob( - os.path.join(CUR_DIR, 'sample_venvs/venv%d%d' % sys.version_info[:2]))) - - -@pytest.mark.parametrize('venv', VENVS) -def test_get_venv_path(venv): - pjoin = os.path.join - venv_path = sys_path.get_venv_path(venv) - - site_pkgs = (glob(pjoin(venv, 'lib', 'python*', 'site-packages')) + - glob(pjoin(venv, 'lib', 'site-packages')))[0] - ETALON = [ - pjoin('/path', 'from', 'egg-link'), - pjoin(site_pkgs, '.', 'relative', 'egg-link', 'path'), - site_pkgs, - pjoin(site_pkgs, 'dir-from-foo-pth'), - ] - - # Ensure that pth and egg-link paths were added. - assert venv_path[:len(ETALON)] == ETALON - - # Ensure that none of venv dirs leaked to the interpreter. - assert not set(sys.path).intersection(ETALON) - - # Ensure that "import ..." lines were ignored. - assert pjoin('/path', 'from', 'smth.py') not in venv_path - assert pjoin('/path', 'from', 'smth.py:extend_path') not in venv_path diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/zipped_imports/not_pkg.zip b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/zipped_imports/not_pkg.zip deleted file mode 100644 index f1516a6..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/zipped_imports/not_pkg.zip and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/zipped_imports/pkg.zip b/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/zipped_imports/pkg.zip deleted file mode 100644 index ec8eac4..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/jedi-0.11.1-py3.6.egg/test/test_evaluate/zipped_imports/pkg.zip and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/DESCRIPTION.rst b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/DESCRIPTION.rst deleted file mode 100644 index 5540416..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/DESCRIPTION.rst +++ /dev/null @@ -1,110 +0,0 @@ -################################################################### -parso - A Python Parser -################################################################### - -.. image:: https://secure.travis-ci.org/davidhalter/parso.png?branch=master - :target: http://travis-ci.org/davidhalter/parso - :alt: Travis-CI build status - -.. image:: https://coveralls.io/repos/davidhalter/parso/badge.png?branch=master - :target: https://coveralls.io/r/davidhalter/parso - :alt: Coverage Status - -.. image:: https://raw.githubusercontent.com/davidhalter/parso/master/docs/_static/logo_characters.png - -Parso is a Python parser that supports error recovery and round-trip parsing -for different Python versions (in multiple Python versions). Parso is also able -to list multiple syntax errors in your python file. - -Parso has been battle-tested by jedi_. It was pulled out of jedi to be useful -for other projects as well. - -Parso consists of a small API to parse Python and analyse the syntax tree. - -A simple example: - -.. code-block:: python - - >>> import parso - >>> module = parso.parse('hello + 1', version="3.6") - >>> expr = module.children[0] - >>> expr - PythonNode(arith_expr, [, , ]) - >>> print(expr.get_code()) - hello + 1 - >>> name = expr.children[0] - >>> name - - >>> name.end_pos - (1, 5) - >>> expr.end_pos - (1, 9) - -To list multiple issues: - -.. code-block:: python - - >>> grammar = parso.load_grammar() - >>> module = grammar.parse('foo +\nbar\ncontinue') - >>> error1, error2 = grammar.iter_errors(module) - >>> error1.message - 'SyntaxError: invalid syntax' - >>> error2.message - "SyntaxError: 'continue' not properly in loop" - -Resources -========= - -- `Testing `_ -- `PyPI `_ -- `Docs `_ -- Uses `semantic versioning `_ - -Installation -============ - - pip install parso - -Future -====== - -- There will be better support for refactoring and comments. Stay tuned. -- There's a WIP PEP8 validator. It's however not in a good shape, yet. - -Known Issues -============ - -- `async`/`await` are already used as keywords in Python3.6. -- `from __future__ import print_function` is not ignored. - - -Acknowledgements -================ - -- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2 - (originally used in lib2to3). -- `Salome Schneider `_ - for the extremely awesome parso logo. - - -.. _jedi: https://github.com/davidhalter/jedi - - -.. :changelog: - -Changelog ---------- - - -0.1.1 (2017-11-05) -+++++++++++++++++++ - -- Fixed a few bugs in the caching layer -- Added support for Python 3.7 - -0.1.0 (2017-09-04) -+++++++++++++++++++ - -- Pulling the library out of Jedi. Some APIs will definitely change. - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/PKG-INFO b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/PKG-INFO deleted file mode 100644 index 76f2b64..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/PKG-INFO +++ /dev/null @@ -1,136 +0,0 @@ -Metadata-Version: 2.0 -Name: parso -Version: 0.1.1 -Summary: A Python Parser -Home-page: https://github.com/davidhalter/parso -Author: David Halter -Author-email: davidhalter88@gmail.com -License: MIT -Keywords: python parser parsing -Platform: any -Classifier: Development Status :: 4 - Beta -Classifier: Environment :: Plugins -Classifier: Intended Audience :: Developers -Classifier: License :: OSI Approved :: MIT License -Classifier: Operating System :: OS Independent -Classifier: Programming Language :: Python :: 2 -Classifier: Programming Language :: Python :: 2.6 -Classifier: Programming Language :: Python :: 2.7 -Classifier: Programming Language :: Python :: 3 -Classifier: Programming Language :: Python :: 3.3 -Classifier: Programming Language :: Python :: 3.4 -Classifier: Programming Language :: Python :: 3.5 -Classifier: Topic :: Software Development :: Libraries :: Python Modules -Classifier: Topic :: Text Editors :: Integrated Development Environments (IDE) -Classifier: Topic :: Utilities - -################################################################### -parso - A Python Parser -################################################################### - -.. image:: https://secure.travis-ci.org/davidhalter/parso.png?branch=master - :target: http://travis-ci.org/davidhalter/parso - :alt: Travis-CI build status - -.. image:: https://coveralls.io/repos/davidhalter/parso/badge.png?branch=master - :target: https://coveralls.io/r/davidhalter/parso - :alt: Coverage Status - -.. image:: https://raw.githubusercontent.com/davidhalter/parso/master/docs/_static/logo_characters.png - -Parso is a Python parser that supports error recovery and round-trip parsing -for different Python versions (in multiple Python versions). Parso is also able -to list multiple syntax errors in your python file. - -Parso has been battle-tested by jedi_. It was pulled out of jedi to be useful -for other projects as well. - -Parso consists of a small API to parse Python and analyse the syntax tree. - -A simple example: - -.. code-block:: python - - >>> import parso - >>> module = parso.parse('hello + 1', version="3.6") - >>> expr = module.children[0] - >>> expr - PythonNode(arith_expr, [, , ]) - >>> print(expr.get_code()) - hello + 1 - >>> name = expr.children[0] - >>> name - - >>> name.end_pos - (1, 5) - >>> expr.end_pos - (1, 9) - -To list multiple issues: - -.. code-block:: python - - >>> grammar = parso.load_grammar() - >>> module = grammar.parse('foo +\nbar\ncontinue') - >>> error1, error2 = grammar.iter_errors(module) - >>> error1.message - 'SyntaxError: invalid syntax' - >>> error2.message - "SyntaxError: 'continue' not properly in loop" - -Resources -========= - -- `Testing `_ -- `PyPI `_ -- `Docs `_ -- Uses `semantic versioning `_ - -Installation -============ - - pip install parso - -Future -====== - -- There will be better support for refactoring and comments. Stay tuned. -- There's a WIP PEP8 validator. It's however not in a good shape, yet. - -Known Issues -============ - -- `async`/`await` are already used as keywords in Python3.6. -- `from __future__ import print_function` is not ignored. - - -Acknowledgements -================ - -- Guido van Rossum (@gvanrossum) for creating the parser generator pgen2 - (originally used in lib2to3). -- `Salome Schneider `_ - for the extremely awesome parso logo. - - -.. _jedi: https://github.com/davidhalter/jedi - - -.. :changelog: - -Changelog ---------- - - -0.1.1 (2017-11-05) -+++++++++++++++++++ - -- Fixed a few bugs in the caching layer -- Added support for Python 3.7 - -0.1.0 (2017-09-04) -+++++++++++++++++++ - -- Pulling the library out of Jedi. Some APIs will definitely change. - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/RECORD b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/RECORD deleted file mode 100644 index a4f1d34..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/RECORD +++ /dev/null @@ -1,35 +0,0 @@ -parso/__init__.py,sha256=Du_INrcX4c1WioBWBNyqyPgmGzcNREiFUt3HRDVLZQI,1607 -parso/_compatibility.py,sha256=34NVhrKOGJkuam2mOWAeR4X7xP8ZFAFgSWRaJuUCHzQ,3440 -parso/cache.py,sha256=eE2lzGWvzawqXVXaTm9vxNbIQ6Vp28RpnvbgoVkFiys,4791 -parso/grammar.py,sha256=lAIVmZeOkybhAbXVjGDVeRN5lzrBEnBBZ0HCAc2cIbo,10910 -parso/normalizer.py,sha256=lO3CBY4W0V-t_b8J4AbtKiDd_ug-6pbFnSUT5uObztY,5169 -parso/parser.py,sha256=u3ZD_OIODvuGfyDjI5kb-GlyxInILzpH0loUTXDGy88,3021 -parso/tree.py,sha256=e3BGIdcpfOYnL6oPPE1sFe3RoBFxEj9xjAXjdwwR4P8,11215 -parso/utils.py,sha256=MCNDj99AxLMSkQ7n6fwYvO-cpHHSSy5gwAQI7kA1LQE,5315 -parso/pgen2/__init__.py,sha256=eb-5tGD73LHn9yEV64RrK5GNMguPOhgFO40h5zXLsgM,337 -parso/pgen2/grammar.py,sha256=JaQRSW5qGPyJ-DUbG5CWTDsuNwSa6F1Io16eTgvzbzQ,4761 -parso/pgen2/parse.py,sha256=HpYtkPQJpwf6hFxwieWv66p2lA2m1cQtCBUsm3xdYkQ,8373 -parso/pgen2/pgen.py,sha256=DbCdBfkDw6hOFI1gkvzF96LutE7a2A1caoNCgfLedfk,14222 -parso/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 -parso/python/diff.py,sha256=l_rPIvgvGqLttvKXwyH2cie6yB2GDfKaeE3pbxrR-eE,22174 -parso/python/errors.py,sha256=PEcIEo57PlqDqme-JTBo0rAIH5l_Ulvr3vJcKuGT4cA,39682 -parso/python/fstring.py,sha256=tAzQLRD0zl5qkdO96UTQJ2lcbA-uGiQs0mNoAwQVaFI,7271 -parso/python/grammar26.txt,sha256=4HcZUd6U1AIGFT30sf82sPnSIh6PZI2gULyZipzGopc,6409 -parso/python/grammar27.txt,sha256=D19Rit8_Q6eCPI0vNTBRkeCvbBaGtNHomMH7z2Pm-Os,5913 -parso/python/grammar33.txt,sha256=oaL8pArlDx_MQ6ZA_OLgeKQ8iFDAnceeh4mSurSPwMU,6079 -parso/python/grammar34.txt,sha256=IlCCTkFYsFd5U7cOMUTx2lbglntqyDzNIYCcFCfxaoI,6083 -parso/python/grammar35.txt,sha256=Hqut450v0A-Z3Bkky5_LjFTGhFUu3smsY5fcTL_JHbA,6888 -parso/python/grammar36.txt,sha256=zV2dBko6cZUY5MWOESDyis-z4xLiVrL23bTT0glCoNQ,6623 -parso/python/grammar37.txt,sha256=zV2dBko6cZUY5MWOESDyis-z4xLiVrL23bTT0glCoNQ,6623 -parso/python/parser.py,sha256=mXd8r-1uS8xYDDNrmVyFz_1AzusbPnm5_7tclPimzFQ,10590 -parso/python/pep8.py,sha256=L-97MV5y89P1T1AsqI4tWUNerd-PEyNAhoh8tLV_tGc,32213 -parso/python/prefix.py,sha256=KNIwOhF6jP6E4QSEpV3ddrj91wm9a7P8OYQb9qe_zpc,2405 -parso/python/token.py,sha256=WqLf4m-GXq4a1NC3gV_PkEAzl_zbvnXT5ieljpB-yzU,1777 -parso/python/tokenize.py,sha256=ll_XLCvDDU2LuwMXm6AeHfM7TLG27CEs5et-ShaQR8g,15857 -parso/python/tree.py,sha256=Pib6GGBsQmq2DG_fS3lczsvpJm8wmMlFGUyklcQJ3ns,34692 -parso-0.1.1.dist-info/DESCRIPTION.rst,sha256=a6mDdwUJK2AZW3lh8No66vjImNrKbrPTBzWw3bKMDZk,2951 -parso-0.1.1.dist-info/METADATA,sha256=uf7zXLH-GTPMwBvgtFwPyTAfdtBquu3bhBWThOaSTNY,3941 -parso-0.1.1.dist-info/RECORD,, -parso-0.1.1.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110 -parso-0.1.1.dist-info/metadata.json,sha256=PPy-agcyVytuszgr-uLRVoktplPtUrTDDtaqT605xLM,1094 -parso-0.1.1.dist-info/top_level.txt,sha256=GOOKQCPcnr0_7IRArxyI0CX5LLu4WLlzIRAVWS-vJ4s,6 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/WHEEL b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/WHEEL deleted file mode 100644 index 8b6dd1b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/WHEEL +++ /dev/null @@ -1,6 +0,0 @@ -Wheel-Version: 1.0 -Generator: bdist_wheel (0.29.0) -Root-Is-Purelib: true -Tag: py2-none-any -Tag: py3-none-any - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/metadata.json b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/metadata.json deleted file mode 100644 index 61a2dc1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"classifiers": ["Development Status :: 4 - Beta", "Environment :: Plugins", "Intended Audience :: Developers", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Programming Language :: Python :: 3.5", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Text Editors :: Integrated Development Environments (IDE)", "Topic :: Utilities"], "extensions": {"python.details": {"contacts": [{"email": "davidhalter88@gmail.com", "name": "David Halter", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/davidhalter/parso"}}}, "generator": "bdist_wheel (0.29.0)", "keywords": ["python", "parser", "parsing"], "license": "MIT", "metadata_version": "2.0", "name": "parso", "platform": "any", "summary": "A Python Parser", "version": "0.1.1"} \ No newline at end of file diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/top_level.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/top_level.txt deleted file mode 100644 index 0e23344..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/EGG-INFO/top_level.txt +++ /dev/null @@ -1 +0,0 @@ -parso diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/__init__.py deleted file mode 100644 index f0a0fc4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/__init__.py +++ /dev/null @@ -1,58 +0,0 @@ -r""" -Parso is a Python parser that supports error recovery and round-trip parsing -for different Python versions (in multiple Python versions). Parso is also able -to list multiple syntax errors in your python file. - -Parso has been battle-tested by jedi_. It was pulled out of jedi to be useful -for other projects as well. - -Parso consists of a small API to parse Python and analyse the syntax tree. - -.. _jedi: https://github.com/davidhalter/jedi - -A simple example: - ->>> import parso ->>> module = parso.parse('hello + 1', version="3.6") ->>> expr = module.children[0] ->>> expr -PythonNode(arith_expr, [, , ]) ->>> print(expr.get_code()) -hello + 1 ->>> name = expr.children[0] ->>> name - ->>> name.end_pos -(1, 5) ->>> expr.end_pos -(1, 9) - -To list multiple issues: - ->>> grammar = parso.load_grammar() ->>> module = grammar.parse('foo +\nbar\ncontinue') ->>> error1, error2 = grammar.iter_errors(module) ->>> error1.message -'SyntaxError: invalid syntax' ->>> error2.message -"SyntaxError: 'continue' not properly in loop" -""" - -from parso.parser import ParserSyntaxError -from parso.grammar import Grammar, load_grammar -from parso.utils import split_lines, python_bytes_to_unicode - - -__version__ = '0.1.1' - - -def parse(code=None, **kwargs): - """ - A utility function to avoid loading grammars. - Params are documented in :py:meth:`parso.Grammar.parse`. - - :param str version: The version used by :py:func:`parso.load_grammar`. - """ - version = kwargs.pop('version', None) - grammar = load_grammar(version=version) - return grammar.parse(code, **kwargs) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/_compatibility.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/_compatibility.py deleted file mode 100644 index 9ddf23d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/_compatibility.py +++ /dev/null @@ -1,103 +0,0 @@ -""" -To ensure compatibility from Python ``2.6`` - ``3.3``, a module has been -created. Clearly there is huge need to use conforming syntax. -""" -import sys -import platform - -# Cannot use sys.version.major and minor names, because in Python 2.6 it's not -# a namedtuple. -py_version = int(str(sys.version_info[0]) + str(sys.version_info[1])) - -# unicode function -try: - unicode = unicode -except NameError: - unicode = str - -is_pypy = platform.python_implementation() == 'PyPy' - - -def use_metaclass(meta, *bases): - """ Create a class with a metaclass. """ - if not bases: - bases = (object,) - return meta("HackClass", bases, {}) - - -try: - encoding = sys.stdout.encoding - if encoding is None: - encoding = 'utf-8' -except AttributeError: - encoding = 'ascii' - - -def u(string): - """Cast to unicode DAMMIT! - Written because Python2 repr always implicitly casts to a string, so we - have to cast back to a unicode (and we now that we always deal with valid - unicode, because we check that in the beginning). - """ - if py_version >= 30: - return str(string) - - if not isinstance(string, unicode): - return unicode(str(string), 'UTF-8') - return string - - -try: - FileNotFoundError = FileNotFoundError -except NameError: - FileNotFoundError = IOError - - -def utf8_repr(func): - """ - ``__repr__`` methods in Python 2 don't allow unicode objects to be - returned. Therefore cast them to utf-8 bytes in this decorator. - """ - def wrapper(self): - result = func(self) - if isinstance(result, unicode): - return result.encode('utf-8') - else: - return result - - if py_version >= 30: - return func - else: - return wrapper - - -try: - from functools import total_ordering -except ImportError: - # Python 2.6 - def total_ordering(cls): - """Class decorator that fills in missing ordering methods""" - convert = { - '__lt__': [('__gt__', lambda self, other: not (self < other or self == other)), - ('__le__', lambda self, other: self < other or self == other), - ('__ge__', lambda self, other: not self < other)], - '__le__': [('__ge__', lambda self, other: not self <= other or self == other), - ('__lt__', lambda self, other: self <= other and not self == other), - ('__gt__', lambda self, other: not self <= other)], - '__gt__': [('__lt__', lambda self, other: not (self > other or self == other)), - ('__ge__', lambda self, other: self > other or self == other), - ('__le__', lambda self, other: not self > other)], - '__ge__': [('__le__', lambda self, other: (not self >= other) or self == other), - ('__gt__', lambda self, other: self >= other and not self == other), - ('__lt__', lambda self, other: not self >= other)] - } - roots = set(dir(cls)) & set(convert) - if not roots: - raise ValueError('must define at least one ordering operation: < > <= >=') - root = max(roots) # prefer __lt__ to __le__ to __gt__ to __ge__ - for opname, opfunc in convert[root]: - if opname not in roots: - opfunc.__name__ = opname - opfunc.__doc__ = getattr(int, opname).__doc__ - setattr(cls, opname, opfunc) - return cls diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/cache.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/cache.py deleted file mode 100644 index d0465d0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/cache.py +++ /dev/null @@ -1,162 +0,0 @@ -import time -import os -import sys -import hashlib -import gc -import shutil -import platform -import errno -import logging - -try: - import cPickle as pickle -except: - import pickle - -from parso._compatibility import FileNotFoundError - -LOG = logging.getLogger(__name__) - - -_PICKLE_VERSION = 30 -""" -Version number (integer) for file system cache. - -Increment this number when there are any incompatible changes in -the parser tree classes. For example, the following changes -are regarded as incompatible. - -- A class name is changed. -- A class is moved to another module. -- A __slot__ of a class is changed. -""" - -_VERSION_TAG = '%s-%s%s-%s' % ( - platform.python_implementation(), - sys.version_info[0], - sys.version_info[1], - _PICKLE_VERSION -) -""" -Short name for distinguish Python implementations and versions. - -It's like `sys.implementation.cache_tag` but for Python < 3.3 -we generate something similar. See: -http://docs.python.org/3/library/sys.html#sys.implementation -""" - -def _get_default_cache_path(): - if platform.system().lower() == 'windows': - dir_ = os.path.join(os.getenv('LOCALAPPDATA') or '~', 'Parso', 'Parso') - elif platform.system().lower() == 'darwin': - dir_ = os.path.join('~', 'Library', 'Caches', 'Parso') - else: - dir_ = os.path.join(os.getenv('XDG_CACHE_HOME') or '~/.cache', 'parso') - return os.path.expanduser(dir_) - -_default_cache_path = _get_default_cache_path() -""" -The path where the cache is stored. - -On Linux, this defaults to ``~/.cache/parso/``, on OS X to -``~/Library/Caches/Parso/`` and on Windows to ``%LOCALAPPDATA%\\Parso\\Parso\\``. -On Linux, if environment variable ``$XDG_CACHE_HOME`` is set, -``$XDG_CACHE_HOME/parso`` is used instead of the default one. -""" - -parser_cache = {} - - -class _NodeCacheItem(object): - def __init__(self, node, lines, change_time=None): - self.node = node - self.lines = lines - if change_time is None: - change_time = time.time() - self.change_time = change_time - - -def load_module(hashed_grammar, path, cache_path=None): - """ - Returns a module or None, if it fails. - """ - try: - p_time = os.path.getmtime(path) - except FileNotFoundError: - return None - - try: - module_cache_item = parser_cache[hashed_grammar][path] - if p_time <= module_cache_item.change_time: - return module_cache_item.node - except KeyError: - return _load_from_file_system(hashed_grammar, path, p_time, cache_path=cache_path) - - -def _load_from_file_system(hashed_grammar, path, p_time, cache_path=None): - cache_path = _get_hashed_path(hashed_grammar, path, cache_path=cache_path) - try: - try: - if p_time > os.path.getmtime(cache_path): - # Cache is outdated - return None - except OSError as e: - if e.errno == errno.ENOENT: - # In Python 2 instead of an IOError here we get an OSError. - raise FileNotFoundError - else: - raise - - with open(cache_path, 'rb') as f: - gc.disable() - try: - module_cache_item = pickle.load(f) - finally: - gc.enable() - except FileNotFoundError: - return None - else: - parser_cache.setdefault(hashed_grammar, {})[path] = module_cache_item - LOG.debug('pickle loaded: %s', path) - return module_cache_item.node - - -def save_module(hashed_grammar, path, module, lines, pickling=True, cache_path=None): - try: - p_time = None if path is None else os.path.getmtime(path) - except OSError: - p_time = None - pickling = False - - item = _NodeCacheItem(module, lines, p_time) - parser_cache.setdefault(hashed_grammar, {})[path] = item - if pickling and path is not None: - _save_to_file_system(hashed_grammar, path, item, cache_path=cache_path) - - -def _save_to_file_system(hashed_grammar, path, item, cache_path=None): - with open(_get_hashed_path(hashed_grammar, path, cache_path=cache_path), 'wb') as f: - pickle.dump(item, f, pickle.HIGHEST_PROTOCOL) - - -def clear_cache(cache_path=None): - if cache_path is None: - cache_path = _default_cache_path - shutil.rmtree(cache_path) - parser_cache.clear() - - -def _get_hashed_path(hashed_grammar, path, cache_path=None): - directory = _get_cache_directory_path(cache_path=cache_path) - - file_hash = hashlib.sha256(path.encode("utf-8")).hexdigest() - return os.path.join(directory, '%s-%s.pkl' % (hashed_grammar, file_hash)) - - -def _get_cache_directory_path(cache_path=None): - if cache_path is None: - cache_path = _default_cache_path - directory = os.path.join(cache_path, _VERSION_TAG) - if not os.path.exists(directory): - os.makedirs(directory) - return directory diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/grammar.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/grammar.py deleted file mode 100644 index 2cf26d7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/grammar.py +++ /dev/null @@ -1,283 +0,0 @@ -import hashlib -import os - -from parso._compatibility import FileNotFoundError, is_pypy -from parso.pgen2.pgen import generate_grammar -from parso.utils import split_lines, python_bytes_to_unicode, parse_version_string -from parso.python.diff import DiffParser -from parso.python.tokenize import tokenize_lines, tokenize -from parso.python import token -from parso.cache import parser_cache, load_module, save_module -from parso.parser import BaseParser -from parso.python.parser import Parser as PythonParser -from parso.python.errors import ErrorFinderConfig -from parso.python import pep8 -from parso.python import fstring - -_loaded_grammars = {} - - -class Grammar(object): - """ - :py:func:`parso.load_grammar` returns instances of this class. - - Creating custom grammars by calling this is not supported, yet. - """ - #:param text: A BNF representation of your grammar. - _error_normalizer_config = None - _token_namespace = None - _default_normalizer_config = pep8.PEP8NormalizerConfig() - - def __init__(self, text, tokenizer, parser=BaseParser, diff_parser=None): - self._pgen_grammar = generate_grammar( - text, - token_namespace=self._get_token_namespace() - ) - self._parser = parser - self._tokenizer = tokenizer - self._diff_parser = diff_parser - self._hashed = hashlib.sha256(text.encode("utf-8")).hexdigest() - - def parse(self, code=None, **kwargs): - """ - If you want to parse a Python file you want to start here, most likely. - - If you need finer grained control over the parsed instance, there will be - other ways to access it. - - :param str code: A unicode or bytes string. When it's not possible to - decode bytes to a string, returns a - :py:class:`UnicodeDecodeError`. - :param bool error_recovery: If enabled, any code will be returned. If - it is invalid, it will be returned as an error node. If disabled, - you will get a ParseError when encountering syntax errors in your - code. - :param str start_symbol: The grammar symbol that you want to parse. Only - allowed to be used when error_recovery is False. - :param str path: The path to the file you want to open. Only needed for caching. - :param bool cache: Keeps a copy of the parser tree in RAM and on disk - if a path is given. Returns the cached trees if the corresponding - files on disk have not changed. - :param bool diff_cache: Diffs the cached python module against the new - code and tries to parse only the parts that have changed. Returns - the same (changed) module that is found in cache. Using this option - requires you to not do anything anymore with the cached modules - under that path, because the contents of it might change. This - option is still somewhat experimental. If you want stability, - please don't use it. - :param bool cache_path: If given saves the parso cache in this - directory. If not given, defaults to the default cache places on - each platform. - - :return: A subclass of :py:class:`parso.tree.NodeOrLeaf`. Typically a - :py:class:`parso.python.tree.Module`. - """ - if 'start_pos' in kwargs: - raise TypeError("parse() got an unexpected keyworda argument.") - return self._parse(code=code, **kwargs) - - def _parse(self, code=None, error_recovery=True, path=None, - start_symbol=None, cache=False, diff_cache=False, - cache_path=None, start_pos=(1, 0)): - """ - Wanted python3.5 * operator and keyword only arguments. Therefore just - wrap it all. - start_pos here is just a parameter internally used. Might be public - sometime in the future. - """ - if code is None and path is None: - raise TypeError("Please provide either code or a path.") - - if start_symbol is None: - start_symbol = self._start_symbol - - if error_recovery and start_symbol != 'file_input': - raise NotImplementedError("This is currently not implemented.") - - if cache and path is not None: - module_node = load_module(self._hashed, path, cache_path=cache_path) - if module_node is not None: - return module_node - - if code is None: - with open(path, 'rb') as f: - code = f.read() - - code = python_bytes_to_unicode(code) - - lines = split_lines(code, keepends=True) - if diff_cache: - if self._diff_parser is None: - raise TypeError("You have to define a diff parser to be able " - "to use this option.") - try: - module_cache_item = parser_cache[self._hashed][path] - except KeyError: - pass - else: - module_node = module_cache_item.node - old_lines = module_cache_item.lines - if old_lines == lines: - return module_node - - new_node = self._diff_parser( - self._pgen_grammar, self._tokenizer, module_node - ).update( - old_lines=old_lines, - new_lines=lines - ) - save_module(self._hashed, path, new_node, lines, - # Never pickle in pypy, it's slow as hell. - pickling=cache and not is_pypy, - cache_path=cache_path) - return new_node - - tokens = self._tokenizer(lines, start_pos) - - p = self._parser( - self._pgen_grammar, - error_recovery=error_recovery, - start_symbol=start_symbol - ) - root_node = p.parse(tokens=tokens) - - if cache or diff_cache: - save_module(self._hashed, path, root_node, lines, - # Never pickle in pypy, it's slow as hell. - pickling=cache and not is_pypy, - cache_path=cache_path) - return root_node - - def _get_token_namespace(self): - ns = self._token_namespace - if ns is None: - raise ValueError("The token namespace should be set.") - return ns - - def iter_errors(self, node): - """ - Given a :py:class:`parso.tree.NodeOrLeaf` returns a generator of - :py:class:`parso.normalizer.Issue` objects. For Python this is - a list of syntax/indentation errors. - """ - if self._error_normalizer_config is None: - raise ValueError("No error normalizer specified for this grammar.") - - return self._get_normalizer_issues(node, self._error_normalizer_config) - - def _get_normalizer(self, normalizer_config): - if normalizer_config is None: - normalizer_config = self._default_normalizer_config - if normalizer_config is None: - raise ValueError("You need to specify a normalizer, because " - "there's no default normalizer for this tree.") - return normalizer_config.create_normalizer(self) - - def _normalize(self, node, normalizer_config=None): - """ - TODO this is not public, yet. - The returned code will be normalized, e.g. PEP8 for Python. - """ - normalizer = self._get_normalizer(normalizer_config) - return normalizer.walk(node) - - def _get_normalizer_issues(self, node, normalizer_config=None): - normalizer = self._get_normalizer(normalizer_config) - normalizer.walk(node) - return normalizer.issues - - - def __repr__(self): - labels = self._pgen_grammar.number2symbol.values() - txt = ' '.join(list(labels)[:3]) + ' ...' - return '<%s:%s>' % (self.__class__.__name__, txt) - - -class PythonGrammar(Grammar): - _error_normalizer_config = ErrorFinderConfig() - _token_namespace = token - _start_symbol = 'file_input' - - def __init__(self, version_info, bnf_text): - super(PythonGrammar, self).__init__( - bnf_text, - tokenizer=self._tokenize_lines, - parser=PythonParser, - diff_parser=DiffParser - ) - self.version_info = version_info - - def _tokenize_lines(self, lines, start_pos): - return tokenize_lines(lines, self.version_info, start_pos=start_pos) - - def _tokenize(self, code): - # Used by Jedi. - return tokenize(code, self.version_info) - - -class PythonFStringGrammar(Grammar): - _token_namespace = fstring.TokenNamespace - _start_symbol = 'fstring' - - def __init__(self): - super(PythonFStringGrammar, self).__init__( - text=fstring.GRAMMAR, - tokenizer=fstring.tokenize, - parser=fstring.Parser - ) - - def parse(self, code, **kwargs): - return self._parse(code, **kwargs) - - def _parse(self, code, error_recovery=True, start_pos=(1, 0)): - tokens = self._tokenizer(code, start_pos=start_pos) - p = self._parser( - self._pgen_grammar, - error_recovery=error_recovery, - start_symbol=self._start_symbol, - ) - return p.parse(tokens=tokens) - - def parse_leaf(self, leaf, error_recovery=True): - code = leaf._get_payload() - return self.parse(code, error_recovery=True, start_pos=leaf.start_pos) - - -def load_grammar(**kwargs): - """ - Loads a :py:class:`parso.Grammar`. The default version is the current Python - version. - - :param str version: A python version string, e.g. ``version='3.3'``. - """ - def load_grammar(language='python', version=None): - if language == 'python': - version_info = parse_version_string(version) - - file = os.path.join( - 'python', - 'grammar%s%s.txt' % (version_info.major, version_info.minor) - ) - - global _loaded_grammars - path = os.path.join(os.path.dirname(__file__), file) - try: - return _loaded_grammars[path] - except KeyError: - try: - with open(path) as f: - bnf_text = f.read() - - grammar = PythonGrammar(version_info, bnf_text) - return _loaded_grammars.setdefault(path, grammar) - except FileNotFoundError: - message = "Python version %s is currently not supported." % version - raise NotImplementedError(message) - elif language == 'python-f-string': - if version is not None: - raise NotImplementedError("Currently different versions are not supported.") - return PythonFStringGrammar() - else: - raise NotImplementedError("No support for language %s." % language) - - return load_grammar(**kwargs) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/normalizer.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/normalizer.py deleted file mode 100644 index 9a3e82e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/normalizer.py +++ /dev/null @@ -1,184 +0,0 @@ -from contextlib import contextmanager - -from parso._compatibility import use_metaclass - - -class _NormalizerMeta(type): - def __new__(cls, name, bases, dct): - new_cls = type.__new__(cls, name, bases, dct) - new_cls.rule_value_classes = {} - new_cls.rule_type_classes = {} - return new_cls - - -class Normalizer(use_metaclass(_NormalizerMeta)): - def __init__(self, grammar, config): - self.grammar = grammar - self._config = config - self.issues = [] - - self._rule_type_instances = self._instantiate_rules('rule_type_classes') - self._rule_value_instances = self._instantiate_rules('rule_value_classes') - - def _instantiate_rules(self, attr): - dct = {} - for base in type(self).mro(): - rules_map = getattr(base, attr, {}) - for type_, rule_classes in rules_map.items(): - new = [rule_cls(self) for rule_cls in rule_classes] - dct.setdefault(type_, []).extend(new) - return dct - - def walk(self, node): - self.initialize(node) - value = self.visit(node) - self.finalize() - return value - - def visit(self, node): - try: - children = node.children - except AttributeError: - return self.visit_leaf(node) - else: - with self.visit_node(node): - return ''.join(self.visit(child) for child in children) - - @contextmanager - def visit_node(self, node): - self._check_type_rules(node) - yield - - def _check_type_rules(self, node): - for rule in self._rule_type_instances.get(node.type, []): - rule.feed_node(node) - - def visit_leaf(self, leaf): - self._check_type_rules(leaf) - - for rule in self._rule_value_instances.get(leaf.value, []): - rule.feed_node(leaf) - - return leaf.prefix + leaf.value - - def initialize(self, node): - pass - - def finalize(self): - pass - - def add_issue(self, node, code, message): - issue = Issue(node, code, message) - if issue not in self.issues: - self.issues.append(issue) - return True - - @classmethod - def register_rule(cls, **kwargs): - """ - Use it as a class decorator:: - - normalizer = Normalizer('grammar', 'config') - @normalizer.register_rule(value='foo') - class MyRule(Rule): - error_code = 42 - """ - return cls._register_rule(**kwargs) - - @classmethod - def _register_rule(cls, value=None, values=(), type=None, types=()): - values = list(values) - types = list(types) - if value is not None: - values.append(value) - if type is not None: - types.append(type) - - if not values and not types: - raise ValueError("You must register at least something.") - - def decorator(rule_cls): - for v in values: - cls.rule_value_classes.setdefault(v, []).append(rule_cls) - for t in types: - cls.rule_type_classes.setdefault(t, []).append(rule_cls) - return rule_cls - - return decorator - - -class NormalizerConfig(object): - normalizer_class = Normalizer - - def create_normalizer(self, grammar): - if self.normalizer_class is None: - return None - - return self.normalizer_class(grammar, self) - - -class Issue(object): - def __init__(self, node, code, message): - self._node = node - self.code = code - """ - An integer code that stands for the type of error. - """ - self.message = message - """ - A message (string) for the issue. - """ - self.start_pos = node.start_pos - """ - The start position position of the error as a tuple (line, column). As - always in |parso| the first line is 1 and the first column 0. - """ - - def __eq__(self, other): - return self.start_pos == other.start_pos and self.code == other.code - - def __ne__(self, other): - return not self.__eq__(other) - - def __hash__(self): - return hash((self.code, self.start_pos)) - - def __repr__(self): - return '<%s: %s>' % (self.__class__.__name__, self.code) - - - -class Rule(object): - code = None - message = None - - def __init__(self, normalizer): - self._normalizer = normalizer - - def is_issue(self, node): - raise NotImplementedError() - - def get_node(self, node): - return node - - def _get_message(self, message): - if message is None: - message = self.message - if message is None: - raise ValueError("The message on the class is not set.") - return message - - def add_issue(self, node, code=None, message=None): - if code is None: - code = self.code - if code is None: - raise ValueError("The error code on the class is not set.") - - message = self._get_message(message) - - self._normalizer.add_issue(node, code, message) - - def feed_node(self, node): - if self.is_issue(node): - issue_node = self.get_node(node) - self.add_issue(issue_node) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/parser.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/parser.py deleted file mode 100644 index 555ebc7..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/parser.py +++ /dev/null @@ -1,78 +0,0 @@ -""" -The ``Parser`` tries to convert the available Python code in an easy to read -format, something like an abstract syntax tree. The classes who represent this -tree, are sitting in the :mod:`parso.tree` module. - -The Python module ``tokenize`` is a very important part in the ``Parser``, -because it splits the code into different words (tokens). Sometimes it looks a -bit messy. Sorry for that! You might ask now: "Why didn't you use the ``ast`` -module for this? Well, ``ast`` does a very good job understanding proper Python -code, but fails to work as soon as there's a single line of broken code. - -There's one important optimization that needs to be known: Statements are not -being parsed completely. ``Statement`` is just a representation of the tokens -within the statement. This lowers memory usage and cpu time and reduces the -complexity of the ``Parser`` (there's another parser sitting inside -``Statement``, which produces ``Array`` and ``Call``). -""" -from parso import tree -from parso.pgen2.parse import PgenParser - - -class ParserSyntaxError(Exception): - """ - Contains error information about the parser tree. - - May be raised as an exception. - """ - def __init__(self, message, error_leaf): - self.message = message - self.error_leaf = error_leaf - - -class BaseParser(object): - node_map = {} - default_node = tree.Node - - leaf_map = { - } - default_leaf = tree.Leaf - - def __init__(self, pgen_grammar, start_symbol='file_input', error_recovery=False): - self._pgen_grammar = pgen_grammar - self._start_symbol = start_symbol - self._error_recovery = error_recovery - - def parse(self, tokens): - start_number = self._pgen_grammar.symbol2number[self._start_symbol] - self.pgen_parser = PgenParser( - self._pgen_grammar, self.convert_node, self.convert_leaf, - self.error_recovery, start_number - ) - - node = self.pgen_parser.parse(tokens) - # The stack is empty now, we don't need it anymore. - del self.pgen_parser - return node - - def error_recovery(self, pgen_grammar, stack, arcs, typ, value, start_pos, prefix, - add_token_callback): - if self._error_recovery: - raise NotImplementedError("Error Recovery is not implemented") - else: - error_leaf = tree.ErrorLeaf('TODO %s' % typ, value, start_pos, prefix) - raise ParserSyntaxError('SyntaxError: invalid syntax', error_leaf) - - def convert_node(self, pgen_grammar, type_, children): - # TODO REMOVE symbol, we don't want type here. - symbol = pgen_grammar.number2symbol[type_] - try: - return self.node_map[symbol](children) - except KeyError: - return self.default_node(symbol, children) - - def convert_leaf(self, pgen_grammar, type_, value, prefix, start_pos): - try: - return self.leaf_map[type_](value, start_pos, prefix) - except KeyError: - return self.default_leaf(value, start_pos, prefix) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/__init__.py deleted file mode 100644 index 1ddae5f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/__init__.py +++ /dev/null @@ -1,8 +0,0 @@ -# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -# Modifications: -# Copyright 2006 Google, Inc. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. -# Copyright 2014 David Halter. Integration into Jedi. -# Modifications are dual-licensed: MIT and PSF. diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/grammar.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/grammar.py deleted file mode 100644 index e5f2114..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/grammar.py +++ /dev/null @@ -1,128 +0,0 @@ -# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -# Modifications: -# Copyright 2014 David Halter. Integration into Jedi. -# Modifications are dual-licensed: MIT and PSF. - -"""This module defines the data structures used to represent a grammar. - -These are a bit arcane because they are derived from the data -structures used by Python's 'pgen' parser generator. - -There's also a table here mapping operators to their names in the -token module; the Python tokenize module reports all operators as the -fallback token code OP, but the parser needs the actual token code. - -""" - -try: - import cPickle as pickle -except: - import pickle - - -class Grammar(object): - """Pgen parsing tables conversion class. - - Once initialized, this class supplies the grammar tables for the - parsing engine implemented by parse.py. The parsing engine - accesses the instance variables directly. The class here does not - provide initialization of the tables; several subclasses exist to - do this (see the conv and pgen modules). - - The load() method reads the tables from a pickle file, which is - much faster than the other ways offered by subclasses. The pickle - file is written by calling dump() (after loading the grammar - tables using a subclass). The report() method prints a readable - representation of the tables to stdout, for debugging. - - The instance variables are as follows: - - symbol2number -- a dict mapping symbol names to numbers. Symbol - numbers are always 256 or higher, to distinguish - them from token numbers, which are between 0 and - 255 (inclusive). - - number2symbol -- a dict mapping numbers to symbol names; - these two are each other's inverse. - - states -- a list of DFAs, where each DFA is a list of - states, each state is a list of arcs, and each - arc is a (i, j) pair where i is a label and j is - a state number. The DFA number is the index into - this list. (This name is slightly confusing.) - Final states are represented by a special arc of - the form (0, j) where j is its own state number. - - dfas -- a dict mapping symbol numbers to (DFA, first) - pairs, where DFA is an item from the states list - above, and first is a set of tokens that can - begin this grammar rule (represented by a dict - whose values are always 1). - - labels -- a list of (x, y) pairs where x is either a token - number or a symbol number, and y is either None - or a string; the strings are keywords. The label - number is the index in this list; label numbers - are used to mark state transitions (arcs) in the - DFAs. - - start -- the number of the grammar's start symbol. - - keywords -- a dict mapping keyword strings to arc labels. - - tokens -- a dict mapping token numbers to arc labels. - - """ - - def __init__(self, bnf_text): - self.symbol2number = {} - self.number2symbol = {} - self.states = [] - self.dfas = {} - self.labels = [(0, "EMPTY")] - self.keywords = {} - self.tokens = {} - self.symbol2label = {} - self.label2symbol = {} - self.start = 256 - - def dump(self, filename): - """Dump the grammar tables to a pickle file.""" - with open(filename, "wb") as f: - pickle.dump(self.__dict__, f, 2) - - def load(self, filename): - """Load the grammar tables from a pickle file.""" - with open(filename, "rb") as f: - d = pickle.load(f) - self.__dict__.update(d) - - def copy(self): - """ - Copy the grammar. - """ - new = self.__class__() - for dict_attr in ("symbol2number", "number2symbol", "dfas", "keywords", - "tokens", "symbol2label"): - setattr(new, dict_attr, getattr(self, dict_attr).copy()) - new.labels = self.labels[:] - new.states = self.states[:] - new.start = self.start - return new - - def report(self): - """Dump the grammar tables to standard output, for debugging.""" - from pprint import pprint - print("s2n") - pprint(self.symbol2number) - print("n2s") - pprint(self.number2symbol) - print("states") - pprint(self.states) - print("dfas") - pprint(self.dfas) - print("labels") - pprint(self.labels) - print("start", self.start) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/parse.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/parse.py deleted file mode 100644 index aaacfce..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/parse.py +++ /dev/null @@ -1,223 +0,0 @@ -# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -# Modifications: -# Copyright 2014 David Halter. Integration into Jedi. -# Modifications are dual-licensed: MIT and PSF. - -""" -Parser engine for the grammar tables generated by pgen. - -The grammar table must be loaded first. - -See Parser/parser.c in the Python distribution for additional info on -how this parsing engine works. -""" - -from parso.python import tokenize - - -class InternalParseError(Exception): - """ - Exception to signal the parser is stuck and error recovery didn't help. - Basically this shouldn't happen. It's a sign that something is really - wrong. - """ - - def __init__(self, msg, type, value, start_pos): - Exception.__init__(self, "%s: type=%r, value=%r, start_pos=%r" % - (msg, tokenize.tok_name[type], value, start_pos)) - self.msg = msg - self.type = type - self.value = value - self.start_pos = start_pos - - -class Stack(list): - def get_tos_nodes(self): - tos = self[-1] - return tos[2][1] - - -def token_to_ilabel(grammar, type_, value): - # Map from token to label - if type_ == tokenize.NAME: - # Check for reserved words (keywords) - try: - return grammar.keywords[value] - except KeyError: - pass - - try: - return grammar.tokens[type_] - except KeyError: - return None - - -class PgenParser(object): - """Parser engine. - - The proper usage sequence is: - - p = Parser(grammar, [converter]) # create instance - p.setup([start]) # prepare for parsing - : - if p.add_token(...): # parse a token - break - root = p.rootnode # root of abstract syntax tree - - A Parser instance may be reused by calling setup() repeatedly. - - A Parser instance contains state pertaining to the current token - sequence, and should not be used concurrently by different threads - to parse separate token sequences. - - See driver.py for how to get input tokens by tokenizing a file or - string. - - Parsing is complete when add_token() returns True; the root of the - abstract syntax tree can then be retrieved from the rootnode - instance variable. When a syntax error occurs, error_recovery() - is called. There is no error recovery; the parser cannot be used - after a syntax error was reported (but it can be reinitialized by - calling setup()). - - """ - - def __init__(self, grammar, convert_node, convert_leaf, error_recovery, start): - """Constructor. - - The grammar argument is a grammar.Grammar instance; see the - grammar module for more information. - - The parser is not ready yet for parsing; you must call the - setup() method to get it started. - - The optional convert argument is a function mapping concrete - syntax tree nodes to abstract syntax tree nodes. If not - given, no conversion is done and the syntax tree produced is - the concrete syntax tree. If given, it must be a function of - two arguments, the first being the grammar (a grammar.Grammar - instance), and the second being the concrete syntax tree node - to be converted. The syntax tree is converted from the bottom - up. - - A concrete syntax tree node is a (type, nodes) tuple, where - type is the node type (a token or symbol number) and nodes - is a list of children for symbols, and None for tokens. - - An abstract syntax tree node may be anything; this is entirely - up to the converter function. - - """ - self.grammar = grammar - self.convert_node = convert_node - self.convert_leaf = convert_leaf - - # Each stack entry is a tuple: (dfa, state, node). - # A node is a tuple: (type, children), - # where children is a list of nodes or None - newnode = (start, []) - stackentry = (self.grammar.dfas[start], 0, newnode) - self.stack = Stack([stackentry]) - self.rootnode = None - self.error_recovery = error_recovery - - def parse(self, tokens): - for type_, value, start_pos, prefix in tokens: - if self.add_token(type_, value, start_pos, prefix): - break - else: - # We never broke out -- EOF is too soon -- Unfinished statement. - # However, the error recovery might have added the token again, if - # the stack is empty, we're fine. - if self.stack: - raise InternalParseError("incomplete input", type_, value, start_pos) - return self.rootnode - - def add_token(self, type_, value, start_pos, prefix): - """Add a token; return True if this is the end of the program.""" - ilabel = token_to_ilabel(self.grammar, type_, value) - - # Loop until the token is shifted; may raise exceptions - _gram = self.grammar - _labels = _gram.labels - _push = self._push - _pop = self._pop - _shift = self._shift - while True: - dfa, state, node = self.stack[-1] - states, first = dfa - arcs = states[state] - # Look for a state with this label - for i, newstate in arcs: - t, v = _labels[i] - if ilabel == i: - # Look it up in the list of labels - assert t < 256 - # Shift a token; we're done with it - _shift(type_, value, newstate, prefix, start_pos) - # Pop while we are in an accept-only state - state = newstate - while states[state] == [(0, state)]: - _pop() - if not self.stack: - # Done parsing! - return True - dfa, state, node = self.stack[-1] - states, first = dfa - # Done with this token - return False - elif t >= 256: - # See if it's a symbol and if we're in its first set - itsdfa = _gram.dfas[t] - itsstates, itsfirst = itsdfa - if ilabel in itsfirst: - # Push a symbol - _push(t, itsdfa, newstate) - break # To continue the outer while loop - else: - if (0, state) in arcs: - # An accepting state, pop it and try something else - _pop() - if not self.stack: - # Done parsing, but another token is input - raise InternalParseError("too much input", type_, value, start_pos) - else: - self.error_recovery(self.grammar, self.stack, arcs, type_, - value, start_pos, prefix, self.add_token) - break - - def _shift(self, type_, value, newstate, prefix, start_pos): - """Shift a token. (Internal)""" - dfa, state, node = self.stack[-1] - newnode = self.convert_leaf(self.grammar, type_, value, prefix, start_pos) - node[-1].append(newnode) - self.stack[-1] = (dfa, newstate, node) - - def _push(self, type_, newdfa, newstate): - """Push a nonterminal. (Internal)""" - dfa, state, node = self.stack[-1] - newnode = (type_, []) - self.stack[-1] = (dfa, newstate, node) - self.stack.append((newdfa, 0, newnode)) - - def _pop(self): - """Pop a nonterminal. (Internal)""" - popdfa, popstate, (type_, children) = self.stack.pop() - # If there's exactly one child, return that child instead of creating a - # new node. We still create expr_stmt and file_input though, because a - # lot of Jedi depends on its logic. - if len(children) == 1: - newnode = children[0] - else: - newnode = self.convert_node(self.grammar, type_, children) - - try: - # Equal to: - # dfa, state, node = self.stack[-1] - # symbol, children = node - self.stack[-1][2][1].append(newnode) - except IndexError: - # Stack is empty, set the rootnode. - self.rootnode = newnode diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/pgen.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/pgen.py deleted file mode 100644 index 10ef6ff..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/pgen2/pgen.py +++ /dev/null @@ -1,399 +0,0 @@ -# Copyright 2004-2005 Elemental Security, Inc. All Rights Reserved. -# Licensed to PSF under a Contributor Agreement. - -# Modifications: -# Copyright 2014 David Halter. Integration into Jedi. -# Modifications are dual-licensed: MIT and PSF. - -from parso.pgen2 import grammar -from parso.python import token -from parso.python import tokenize -from parso.utils import parse_version_string - - -class ParserGenerator(object): - def __init__(self, bnf_text, token_namespace): - self._bnf_text = bnf_text - self.generator = tokenize.tokenize( - bnf_text, - version_info=parse_version_string('3.6') - ) - self._gettoken() # Initialize lookahead - self.dfas, self.startsymbol = self._parse() - self.first = {} # map from symbol name to set of tokens - self._addfirstsets() - self._token_namespace = token_namespace - - def make_grammar(self): - c = grammar.Grammar(self._bnf_text) - names = list(self.dfas.keys()) - names.sort() - names.remove(self.startsymbol) - names.insert(0, self.startsymbol) - for name in names: - i = 256 + len(c.symbol2number) - c.symbol2number[name] = i - c.number2symbol[i] = name - for name in names: - dfa = self.dfas[name] - states = [] - for state in dfa: - arcs = [] - for label, next in state.arcs.items(): - arcs.append((self._make_label(c, label), dfa.index(next))) - if state.isfinal: - arcs.append((0, dfa.index(state))) - states.append(arcs) - c.states.append(states) - c.dfas[c.symbol2number[name]] = (states, self._make_first(c, name)) - c.start = c.symbol2number[self.startsymbol] - return c - - def _make_first(self, c, name): - rawfirst = self.first[name] - first = {} - for label in rawfirst: - ilabel = self._make_label(c, label) - ##assert ilabel not in first # XXX failed on <> ... != - first[ilabel] = 1 - return first - - def _make_label(self, c, label): - # XXX Maybe this should be a method on a subclass of converter? - ilabel = len(c.labels) - if label[0].isalpha(): - # Either a symbol name or a named token - if label in c.symbol2number: - # A symbol name (a non-terminal) - if label in c.symbol2label: - return c.symbol2label[label] - else: - c.labels.append((c.symbol2number[label], None)) - c.symbol2label[label] = ilabel - c.label2symbol[ilabel] = label - return ilabel - else: - # A named token (NAME, NUMBER, STRING) - itoken = getattr(self._token_namespace, label, None) - assert isinstance(itoken, int), label - if itoken in c.tokens: - return c.tokens[itoken] - else: - c.labels.append((itoken, None)) - c.tokens[itoken] = ilabel - return ilabel - else: - # Either a keyword or an operator - assert label[0] in ('"', "'"), label - value = eval(label) - if value[0].isalpha(): - # A keyword - if value in c.keywords: - return c.keywords[value] - else: - # TODO this might be an issue?! Using token.NAME here? - c.labels.append((token.NAME, value)) - c.keywords[value] = ilabel - return ilabel - else: - # An operator (any non-numeric token) - itoken = self._token_namespace.generate_token_id(value) - if itoken in c.tokens: - return c.tokens[itoken] - else: - c.labels.append((itoken, None)) - c.tokens[itoken] = ilabel - return ilabel - - def _addfirstsets(self): - names = list(self.dfas.keys()) - names.sort() - for name in names: - if name not in self.first: - self._calcfirst(name) - #print name, self.first[name].keys() - - def _calcfirst(self, name): - dfa = self.dfas[name] - self.first[name] = None # dummy to detect left recursion - state = dfa[0] - totalset = {} - overlapcheck = {} - for label, next in state.arcs.items(): - if label in self.dfas: - if label in self.first: - fset = self.first[label] - if fset is None: - raise ValueError("recursion for rule %r" % name) - else: - self._calcfirst(label) - fset = self.first[label] - totalset.update(fset) - overlapcheck[label] = fset - else: - totalset[label] = 1 - overlapcheck[label] = {label: 1} - inverse = {} - for label, itsfirst in overlapcheck.items(): - for symbol in itsfirst: - if symbol in inverse: - raise ValueError("rule %s is ambiguous; %s is in the" - " first sets of %s as well as %s" % - (name, symbol, label, inverse[symbol])) - inverse[symbol] = label - self.first[name] = totalset - - def _parse(self): - dfas = {} - startsymbol = None - # MSTART: (NEWLINE | RULE)* ENDMARKER - while self.type != token.ENDMARKER: - while self.type == token.NEWLINE: - self._gettoken() - # RULE: NAME ':' RHS NEWLINE - name = self._expect(token.NAME) - self._expect(token.COLON) - a, z = self._parse_rhs() - self._expect(token.NEWLINE) - #self._dump_nfa(name, a, z) - dfa = self._make_dfa(a, z) - #self._dump_dfa(name, dfa) - # oldlen = len(dfa) - self._simplify_dfa(dfa) - # newlen = len(dfa) - dfas[name] = dfa - #print name, oldlen, newlen - if startsymbol is None: - startsymbol = name - return dfas, startsymbol - - def _make_dfa(self, start, finish): - # To turn an NFA into a DFA, we define the states of the DFA - # to correspond to *sets* of states of the NFA. Then do some - # state reduction. Let's represent sets as dicts with 1 for - # values. - assert isinstance(start, NFAState) - assert isinstance(finish, NFAState) - - def closure(state): - base = {} - addclosure(state, base) - return base - - def addclosure(state, base): - assert isinstance(state, NFAState) - if state in base: - return - base[state] = 1 - for label, next in state.arcs: - if label is None: - addclosure(next, base) - - states = [DFAState(closure(start), finish)] - for state in states: # NB states grows while we're iterating - arcs = {} - for nfastate in state.nfaset: - for label, next in nfastate.arcs: - if label is not None: - addclosure(next, arcs.setdefault(label, {})) - for label, nfaset in arcs.items(): - for st in states: - if st.nfaset == nfaset: - break - else: - st = DFAState(nfaset, finish) - states.append(st) - state.addarc(st, label) - return states # List of DFAState instances; first one is start - - def _dump_nfa(self, name, start, finish): - print("Dump of NFA for", name) - todo = [start] - for i, state in enumerate(todo): - print(" State", i, state is finish and "(final)" or "") - for label, next in state.arcs: - if next in todo: - j = todo.index(next) - else: - j = len(todo) - todo.append(next) - if label is None: - print(" -> %d" % j) - else: - print(" %s -> %d" % (label, j)) - - def _dump_dfa(self, name, dfa): - print("Dump of DFA for", name) - for i, state in enumerate(dfa): - print(" State", i, state.isfinal and "(final)" or "") - for label, next in state.arcs.items(): - print(" %s -> %d" % (label, dfa.index(next))) - - def _simplify_dfa(self, dfa): - # This is not theoretically optimal, but works well enough. - # Algorithm: repeatedly look for two states that have the same - # set of arcs (same labels pointing to the same nodes) and - # unify them, until things stop changing. - - # dfa is a list of DFAState instances - changes = True - while changes: - changes = False - for i, state_i in enumerate(dfa): - for j in range(i + 1, len(dfa)): - state_j = dfa[j] - if state_i == state_j: - #print " unify", i, j - del dfa[j] - for state in dfa: - state.unifystate(state_j, state_i) - changes = True - break - - def _parse_rhs(self): - # RHS: ALT ('|' ALT)* - a, z = self._parse_alt() - if self.value != "|": - return a, z - else: - aa = NFAState() - zz = NFAState() - aa.addarc(a) - z.addarc(zz) - while self.value == "|": - self._gettoken() - a, z = self._parse_alt() - aa.addarc(a) - z.addarc(zz) - return aa, zz - - def _parse_alt(self): - # ALT: ITEM+ - a, b = self._parse_item() - while (self.value in ("(", "[") or - self.type in (token.NAME, token.STRING)): - c, d = self._parse_item() - b.addarc(c) - b = d - return a, b - - def _parse_item(self): - # ITEM: '[' RHS ']' | ATOM ['+' | '*'] - if self.value == "[": - self._gettoken() - a, z = self._parse_rhs() - self._expect(token.RSQB) - a.addarc(z) - return a, z - else: - a, z = self._parse_atom() - value = self.value - if value not in ("+", "*"): - return a, z - self._gettoken() - z.addarc(a) - if value == "+": - return a, z - else: - return a, a - - def _parse_atom(self): - # ATOM: '(' RHS ')' | NAME | STRING - if self.value == "(": - self._gettoken() - a, z = self._parse_rhs() - self._expect(token.RPAR) - return a, z - elif self.type in (token.NAME, token.STRING): - a = NFAState() - z = NFAState() - a.addarc(z, self.value) - self._gettoken() - return a, z - else: - self._raise_error("expected (...) or NAME or STRING, got %s/%s", - self.type, self.value) - - def _expect(self, type): - if self.type != type: - self._raise_error("expected %s, got %s(%s)", - type, self.type, self.value) - value = self.value - self._gettoken() - return value - - def _gettoken(self): - tup = next(self.generator) - while tup[0] in (token.COMMENT, token.NL): - tup = next(self.generator) - self.type, self.value, self.begin, prefix = tup - - def _raise_error(self, msg, *args): - if args: - try: - msg = msg % args - except: - msg = " ".join([msg] + list(map(str, args))) - line = self._bnf_text.splitlines()[self.begin[0] - 1] - raise SyntaxError(msg, ('', self.begin[0], - self.begin[1], line)) - - -class NFAState(object): - def __init__(self): - self.arcs = [] # list of (label, NFAState) pairs - - def addarc(self, next, label=None): - assert label is None or isinstance(label, str) - assert isinstance(next, NFAState) - self.arcs.append((label, next)) - - -class DFAState(object): - def __init__(self, nfaset, final): - assert isinstance(nfaset, dict) - assert isinstance(next(iter(nfaset)), NFAState) - assert isinstance(final, NFAState) - self.nfaset = nfaset - self.isfinal = final in nfaset - self.arcs = {} # map from label to DFAState - - def addarc(self, next, label): - assert isinstance(label, str) - assert label not in self.arcs - assert isinstance(next, DFAState) - self.arcs[label] = next - - def unifystate(self, old, new): - for label, next in self.arcs.items(): - if next is old: - self.arcs[label] = new - - def __eq__(self, other): - # Equality test -- ignore the nfaset instance variable - assert isinstance(other, DFAState) - if self.isfinal != other.isfinal: - return False - # Can't just return self.arcs == other.arcs, because that - # would invoke this method recursively, with cycles... - if len(self.arcs) != len(other.arcs): - return False - for label, next in self.arcs.items(): - if next is not other.arcs.get(label): - return False - return True - - __hash__ = None # For Py3 compatibility. - - -def generate_grammar(bnf_text, token_namespace): - """ - ``bnf_text`` is a grammar in extended BNF (using * for repetition, + for - at-least-once repetition, [] for optional parts, | for alternatives and () - for grouping). - - It's not EBNF according to ISO/IEC 14977. It's a dialect Python uses in its - own parser. - """ - p = ParserGenerator(bnf_text, token_namespace) - return p.make_grammar() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/diff.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/diff.py deleted file mode 100644 index c2e44fd..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/diff.py +++ /dev/null @@ -1,587 +0,0 @@ -""" -Basically a contains parser that is faster, because it tries to parse only -parts and if anything changes, it only reparses the changed parts. - -It works with a simple diff in the beginning and will try to reuse old parser -fragments. -""" -import re -import difflib -from collections import namedtuple -import logging - -from parso.utils import split_lines -from parso.python.parser import Parser -from parso.python.tree import EndMarker -from parso.python.tokenize import (NEWLINE, PythonToken, ERROR_DEDENT, - ENDMARKER, INDENT, DEDENT) - -LOG = logging.getLogger(__name__) - - -def _get_last_line(node_or_leaf): - last_leaf = node_or_leaf.get_last_leaf() - if _ends_with_newline(last_leaf): - return last_leaf.start_pos[0] - else: - return last_leaf.end_pos[0] - - -def _ends_with_newline(leaf, suffix=''): - if leaf.type == 'error_leaf': - typ = leaf.original_type - else: - typ = leaf.type - - return typ == 'newline' or suffix.endswith('\n') - - -def _flows_finished(pgen_grammar, stack): - """ - if, while, for and try might not be finished, because another part might - still be parsed. - """ - for dfa, newstate, (symbol_number, nodes) in stack: - if pgen_grammar.number2symbol[symbol_number] in ('if_stmt', 'while_stmt', - 'for_stmt', 'try_stmt'): - return False - return True - - -def suite_or_file_input_is_valid(pgen_grammar, stack): - if not _flows_finished(pgen_grammar, stack): - return False - - for dfa, newstate, (symbol_number, nodes) in reversed(stack): - if pgen_grammar.number2symbol[symbol_number] == 'suite': - # If only newline is in the suite, the suite is not valid, yet. - return len(nodes) > 1 - # Not reaching a suite means that we're dealing with file_input levels - # where there's no need for a valid statement in it. It can also be empty. - return True - - -def _is_flow_node(node): - try: - value = node.children[0].value - except AttributeError: - return False - return value in ('if', 'for', 'while', 'try') - - -class _PositionUpdatingFinished(Exception): - pass - - -def _update_positions(nodes, line_offset, last_leaf): - for node in nodes: - try: - children = node.children - except AttributeError: - # Is a leaf - node.line += line_offset - if node is last_leaf: - raise _PositionUpdatingFinished - else: - _update_positions(children, line_offset, last_leaf) - - -class DiffParser(object): - """ - An advanced form of parsing a file faster. Unfortunately comes with huge - side effects. It changes the given module. - """ - def __init__(self, pgen_grammar, tokenizer, module): - self._pgen_grammar = pgen_grammar - self._tokenizer = tokenizer - self._module = module - - def _reset(self): - self._copy_count = 0 - self._parser_count = 0 - - self._nodes_stack = _NodesStack(self._module) - - def update(self, old_lines, new_lines): - ''' - The algorithm works as follows: - - Equal: - - Assure that the start is a newline, otherwise parse until we get - one. - - Copy from parsed_until_line + 1 to max(i2 + 1) - - Make sure that the indentation is correct (e.g. add DEDENT) - - Add old and change positions - Insert: - - Parse from parsed_until_line + 1 to min(j2 + 1), hopefully not - much more. - - Returns the new module node. - ''' - LOG.debug('diff parser start') - # Reset the used names cache so they get regenerated. - self._module._used_names = None - - self._parser_lines_new = new_lines - - self._reset() - - line_length = len(new_lines) - sm = difflib.SequenceMatcher(None, old_lines, self._parser_lines_new) - opcodes = sm.get_opcodes() - LOG.debug('diff parser calculated') - LOG.debug('diff: line_lengths old: %s, new: %s' % (len(old_lines), line_length)) - - for operation, i1, i2, j1, j2 in opcodes: - LOG.debug('diff %s old[%s:%s] new[%s:%s]', - operation, i1 + 1, i2, j1 + 1, j2) - - if j2 == line_length and new_lines[-1] == '': - # The empty part after the last newline is not relevant. - j2 -= 1 - - if operation == 'equal': - line_offset = j1 - i1 - self._copy_from_old_parser(line_offset, i2, j2) - elif operation == 'replace': - self._parse(until_line=j2) - elif operation == 'insert': - self._parse(until_line=j2) - else: - assert operation == 'delete' - - # With this action all change will finally be applied and we have a - # changed module. - self._nodes_stack.close() - - last_pos = self._module.end_pos[0] - if last_pos != line_length: - current_lines = split_lines(self._module.get_code(), keepends=True) - diff = difflib.unified_diff(current_lines, new_lines) - raise Exception( - "There's an issue (%s != %s) with the diff parser. Please report:\n%s" - % (last_pos, line_length, ''.join(diff)) - ) - - LOG.debug('diff parser end') - return self._module - - def _enabled_debugging(self, old_lines, lines_new): - if self._module.get_code() != ''.join(lines_new): - LOG.warning('parser issue:\n%s\n%s', ''.join(old_lines), - ''.join(lines_new)) - - def _copy_from_old_parser(self, line_offset, until_line_old, until_line_new): - copied_nodes = [None] - - last_until_line = -1 - while until_line_new > self._nodes_stack.parsed_until_line: - parsed_until_line_old = self._nodes_stack.parsed_until_line - line_offset - line_stmt = self._get_old_line_stmt(parsed_until_line_old + 1) - if line_stmt is None: - # Parse 1 line at least. We don't need more, because we just - # want to get into a state where the old parser has statements - # again that can be copied (e.g. not lines within parentheses). - self._parse(self._nodes_stack.parsed_until_line + 1) - elif not copied_nodes: - # We have copied as much as possible (but definitely not too - # much). Therefore we just parse the rest. - # We might not reach the end, because there's a statement - # that is not finished. - self._parse(until_line_new) - else: - p_children = line_stmt.parent.children - index = p_children.index(line_stmt) - - copied_nodes = self._nodes_stack.copy_nodes( - p_children[index:], - until_line_old, - line_offset - ) - # Match all the nodes that are in the wanted range. - if copied_nodes: - self._copy_count += 1 - - from_ = copied_nodes[0].get_start_pos_of_prefix()[0] + line_offset - to = self._nodes_stack.parsed_until_line - - LOG.debug('diff actually copy %s to %s', from_, to) - # Since there are potential bugs that might loop here endlessly, we - # just stop here. - assert last_until_line != self._nodes_stack.parsed_until_line \ - or not copied_nodes, last_until_line - last_until_line = self._nodes_stack.parsed_until_line - - def _get_old_line_stmt(self, old_line): - leaf = self._module.get_leaf_for_position((old_line, 0), include_prefixes=True) - - if _ends_with_newline(leaf): - leaf = leaf.get_next_leaf() - if leaf.get_start_pos_of_prefix()[0] == old_line: - node = leaf - while node.parent.type not in ('file_input', 'suite'): - node = node.parent - return node - # Must be on the same line. Otherwise we need to parse that bit. - return None - - def _get_before_insertion_node(self): - if self._nodes_stack.is_empty(): - return None - - line = self._nodes_stack.parsed_until_line + 1 - node = self._new_module.get_last_leaf() - while True: - parent = node.parent - if parent.type in ('suite', 'file_input'): - assert node.end_pos[0] <= line - assert node.end_pos[1] == 0 or '\n' in self._prefix - return node - node = parent - - def _parse(self, until_line): - """ - Parses at least until the given line, but might just parse more until a - valid state is reached. - """ - last_until_line = 0 - while until_line > self._nodes_stack.parsed_until_line: - node = self._try_parse_part(until_line) - nodes = node.children - - self._nodes_stack.add_parsed_nodes(nodes) - LOG.debug( - 'parse_part from %s to %s (to %s in part parser)', - nodes[0].get_start_pos_of_prefix()[0], - self._nodes_stack.parsed_until_line, - node.end_pos[0] - 1 - ) - # Since the tokenizer sometimes has bugs, we cannot be sure that - # this loop terminates. Therefore assert that there's always a - # change. - assert last_until_line != self._nodes_stack.parsed_until_line, last_until_line - last_until_line = self._nodes_stack.parsed_until_line - - def _try_parse_part(self, until_line): - """ - Sets up a normal parser that uses a spezialized tokenizer to only parse - until a certain position (or a bit longer if the statement hasn't - ended. - """ - self._parser_count += 1 - # TODO speed up, shouldn't copy the whole list all the time. - # memoryview? - parsed_until_line = self._nodes_stack.parsed_until_line - lines_after = self._parser_lines_new[parsed_until_line:] - #print('parse_content', parsed_until_line, lines_after, until_line) - tokens = self._diff_tokenize( - lines_after, - until_line, - line_offset=parsed_until_line - ) - self._active_parser = Parser( - self._pgen_grammar, - error_recovery=True - ) - return self._active_parser.parse(tokens=tokens) - - def _diff_tokenize(self, lines, until_line, line_offset=0): - is_first_token = True - omitted_first_indent = False - indents = [] - tokens = self._tokenizer(lines, (1, 0)) - stack = self._active_parser.pgen_parser.stack - for typ, string, start_pos, prefix in tokens: - start_pos = start_pos[0] + line_offset, start_pos[1] - if typ == INDENT: - indents.append(start_pos[1]) - if is_first_token: - omitted_first_indent = True - # We want to get rid of indents that are only here because - # we only parse part of the file. These indents would only - # get parsed as error leafs, which doesn't make any sense. - is_first_token = False - continue - is_first_token = False - - # In case of omitted_first_indent, it might not be dedented fully. - # However this is a sign for us that a dedent happened. - if typ == DEDENT \ - or typ == ERROR_DEDENT and omitted_first_indent and len(indents) == 1: - indents.pop() - if omitted_first_indent and not indents: - # We are done here, only thing that can come now is an - # endmarker or another dedented code block. - typ, string, start_pos, prefix = next(tokens) - if '\n' in prefix: - prefix = re.sub(r'(<=\n)[^\n]+$', '', prefix) - else: - prefix = '' - yield PythonToken(ENDMARKER, '', (start_pos[0] + line_offset, 0), prefix) - break - elif typ == NEWLINE and start_pos[0] >= until_line: - yield PythonToken(typ, string, start_pos, prefix) - # Check if the parser is actually in a valid suite state. - if suite_or_file_input_is_valid(self._pgen_grammar, stack): - start_pos = start_pos[0] + 1, 0 - while len(indents) > int(omitted_first_indent): - indents.pop() - yield PythonToken(DEDENT, '', start_pos, '') - - yield PythonToken(ENDMARKER, '', start_pos, '') - break - else: - continue - - yield PythonToken(typ, string, start_pos, prefix) - - -class _NodesStackNode(object): - ChildrenGroup = namedtuple('ChildrenGroup', 'children line_offset last_line_offset_leaf') - - def __init__(self, tree_node, parent=None): - self.tree_node = tree_node - self.children_groups = [] - self.parent = parent - - def close(self): - children = [] - for children_part, line_offset, last_line_offset_leaf in self.children_groups: - if line_offset != 0: - try: - _update_positions( - children_part, line_offset, last_line_offset_leaf) - except _PositionUpdatingFinished: - pass - children += children_part - self.tree_node.children = children - # Reset the parents - for node in children: - node.parent = self.tree_node - - def add(self, children, line_offset=0, last_line_offset_leaf=None): - group = self.ChildrenGroup(children, line_offset, last_line_offset_leaf) - self.children_groups.append(group) - - def get_last_line(self, suffix): - line = 0 - if self.children_groups: - children_group = self.children_groups[-1] - last_leaf = children_group.children[-1].get_last_leaf() - line = last_leaf.end_pos[0] - - # Calculate the line offsets - offset = children_group.line_offset - if offset: - # In case the line_offset is not applied to this specific leaf, - # just ignore it. - if last_leaf.line <= children_group.last_line_offset_leaf.line: - line += children_group.line_offset - - # Newlines end on the next line, which means that they would cover - # the next line. That line is not fully parsed at this point. - if _ends_with_newline(last_leaf, suffix): - line -= 1 - line += suffix.count('\n') - if suffix and not suffix.endswith('\n'): - # This is the end of a file (that doesn't end with a newline). - line += 1 - return line - - -class _NodesStack(object): - endmarker_type = 'endmarker' - - def __init__(self, module): - # Top of stack - self._tos = self._base_node = _NodesStackNode(module) - self._module = module - self._last_prefix = '' - self.prefix = '' - - def is_empty(self): - return not self._base_node.children - - @property - def parsed_until_line(self): - return self._tos.get_last_line(self.prefix) - - def _get_insertion_node(self, indentation_node): - indentation = indentation_node.start_pos[1] - - # find insertion node - node = self._tos - while True: - tree_node = node.tree_node - if tree_node.type == 'suite': - # A suite starts with NEWLINE, ... - node_indentation = tree_node.children[1].start_pos[1] - - if indentation >= node_indentation: # Not a Dedent - # We might be at the most outer layer: modules. We - # don't want to depend on the first statement - # having the right indentation. - return node - - elif tree_node.type == 'file_input': - return node - - node = self._close_tos() - - def _close_tos(self): - self._tos.close() - self._tos = self._tos.parent - return self._tos - - def add_parsed_nodes(self, tree_nodes): - tree_nodes = self._remove_endmarker(tree_nodes) - if not tree_nodes: - return - - assert tree_nodes[0].type != 'newline' - - node = self._get_insertion_node(tree_nodes[0]) - assert node.tree_node.type in ('suite', 'file_input') - node.add(tree_nodes) - self._update_tos(tree_nodes[-1]) - - def _remove_endmarker(self, tree_nodes): - """ - Helps cleaning up the tree nodes that get inserted. - """ - last_leaf = tree_nodes[-1].get_last_leaf() - is_endmarker = last_leaf.type == self.endmarker_type - self._last_prefix = '' - if is_endmarker: - try: - separation = last_leaf.prefix.rindex('\n') - except ValueError: - pass - else: - # Remove the whitespace part of the prefix after a newline. - # That is not relevant if parentheses were opened. Always parse - # until the end of a line. - last_leaf.prefix, self._last_prefix = \ - last_leaf.prefix[:separation + 1], last_leaf.prefix[separation + 1:] - - first_leaf = tree_nodes[0].get_first_leaf() - first_leaf.prefix = self.prefix + first_leaf.prefix - self.prefix = '' - - if is_endmarker: - self.prefix = last_leaf.prefix - - tree_nodes = tree_nodes[:-1] - - return tree_nodes - - def copy_nodes(self, tree_nodes, until_line, line_offset): - """ - Copies tree nodes from the old parser tree. - - Returns the number of tree nodes that were copied. - """ - tos = self._get_insertion_node(tree_nodes[0]) - - new_nodes, self._tos = self._copy_nodes(tos, tree_nodes, until_line, line_offset) - return new_nodes - - def _copy_nodes(self, tos, nodes, until_line, line_offset): - new_nodes = [] - - new_tos = tos - for node in nodes: - if node.type == 'endmarker': - # Endmarkers just distort all the checks below. Remove them. - break - - if node.start_pos[0] > until_line: - break - # TODO this check might take a bit of time for large files. We - # might want to change this to do more intelligent guessing or - # binary search. - if _get_last_line(node) > until_line: - # We can split up functions and classes later. - if node.type in ('classdef', 'funcdef') and node.children[-1].type == 'suite': - new_nodes.append(node) - break - - new_nodes.append(node) - - if not new_nodes: - return [], tos - - last_node = new_nodes[-1] - line_offset_index = -1 - if last_node.type in ('classdef', 'funcdef'): - suite = last_node.children[-1] - if suite.type == 'suite': - suite_tos = _NodesStackNode(suite) - # Don't need to pass line_offset here, it's already done by the - # parent. - suite_nodes, recursive_tos = self._copy_nodes( - suite_tos, suite.children, until_line, line_offset) - if len(suite_nodes) < 2: - # A suite only with newline is not valid. - new_nodes.pop() - else: - suite_tos.parent = tos - new_tos = recursive_tos - line_offset_index = -2 - - elif (new_nodes[-1].type in ('error_leaf', 'error_node') or - _is_flow_node(new_nodes[-1])): - # Error leafs/nodes don't have a defined start/end. Error - # nodes might not end with a newline (e.g. if there's an - # open `(`). Therefore ignore all of them unless they are - # succeeded with valid parser state. - # If we copy flows at the end, they might be continued - # after the copy limit (in the new parser). - # In this while loop we try to remove until we find a newline. - new_nodes.pop() - while new_nodes: - last_node = new_nodes[-1] - if last_node.get_last_leaf().type == 'newline': - break - new_nodes.pop() - - if new_nodes: - try: - last_line_offset_leaf = new_nodes[line_offset_index].get_last_leaf() - except IndexError: - line_offset = 0 - # In this case we don't have to calculate an offset, because - # there's no children to be managed. - last_line_offset_leaf = None - tos.add(new_nodes, line_offset, last_line_offset_leaf) - return new_nodes, new_tos - - def _update_tos(self, tree_node): - if tree_node.type in ('suite', 'file_input'): - self._tos = _NodesStackNode(tree_node, self._tos) - self._tos.add(list(tree_node.children)) - self._update_tos(tree_node.children[-1]) - elif tree_node.type in ('classdef', 'funcdef'): - self._update_tos(tree_node.children[-1]) - - def close(self): - while self._tos is not None: - self._close_tos() - - # Add an endmarker. - try: - last_leaf = self._module.get_last_leaf() - end_pos = list(last_leaf.end_pos) - except IndexError: - end_pos = [1, 0] - lines = split_lines(self.prefix) - assert len(lines) > 0 - if len(lines) == 1: - end_pos[1] += len(lines[0]) - else: - end_pos[0] += len(lines) - 1 - end_pos[1] = len(lines[-1]) - - endmarker = EndMarker('', tuple(end_pos), self.prefix + self._last_prefix) - endmarker.parent = self._module - self._module.children.append(endmarker) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/errors.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/errors.py deleted file mode 100644 index 6529656..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/errors.py +++ /dev/null @@ -1,1053 +0,0 @@ -# -*- coding: utf-8 -*- -import codecs -import warnings -import re -from contextlib import contextmanager - -from parso.normalizer import Normalizer, NormalizerConfig, Issue, Rule -from parso.python.tree import search_ancestor -from parso.parser import ParserSyntaxError - -_BLOCK_STMTS = ('if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', 'with_stmt') -_STAR_EXPR_PARENTS = ('testlist_star_expr', 'testlist_comp', 'exprlist') -# This is the maximal block size given by python. -_MAX_BLOCK_SIZE = 20 -_MAX_INDENT_COUNT = 100 -ALLOWED_FUTURES = ( - 'all_feature_names', 'nested_scopes', 'generators', 'division', - 'absolute_import', 'with_statement', 'print_function', 'unicode_literals', -) - - -def _iter_stmts(scope): - """ - Iterates over all statements and splits up simple_stmt. - """ - for child in scope.children: - if child.type == 'simple_stmt': - for child2 in child.children: - if child2.type == 'newline' or child2 == ';': - continue - yield child2 - else: - yield child - - -def _get_comprehension_type(atom): - first, second = atom.children[:2] - if second.type == 'testlist_comp' and second.children[1].type == 'comp_for': - if first == '[': - return 'list comprehension' - else: - return 'generator expression' - elif second.type == 'dictorsetmaker' and second.children[-1].type == 'comp_for': - if second.children[1] == ':': - return 'dict comprehension' - else: - return 'set comprehension' - return None - - -def _is_future_import(import_from): - # It looks like a __future__ import that is relative is still a future - # import. That feels kind of odd, but whatever. - # if import_from.level != 0: - # return False - from_names = import_from.get_from_names() - return [n.value for n in from_names] == ['__future__'] - - -def _remove_parens(atom): - """ - Returns the inner part of an expression like `(foo)`. Also removes nested - parens. - """ - try: - children = atom.children - except AttributeError: - pass - else: - if len(children) == 3 and children[0] == '(': - return _remove_parens(atom.children[1]) - return atom - - -def _iter_params(parent_node): - return (n for n in parent_node.children if n.type == 'param') - - -def _is_future_import_first(import_from): - """ - Checks if the import is the first statement of a file. - """ - found_docstring = False - for stmt in _iter_stmts(import_from.get_root_node()): - if stmt.type == 'string' and not found_docstring: - continue - found_docstring = True - - if stmt == import_from: - return True - if stmt.type == 'import_from' and _is_future_import(stmt): - continue - return False - - -def _iter_definition_exprs_from_lists(exprlist): - for child in exprlist.children[::2]: - if child.type == 'atom' and child.children[0] in ('(', '['): - testlist_comp = child.children[0] - if testlist_comp.type == 'testlist_comp': - for expr in _iter_definition_exprs_from_lists(testlist_comp): - yield expr - continue - elif child.children[0] == '[': - yield testlist_comp - continue - - yield child - -def _get_expr_stmt_definition_exprs(expr_stmt): - exprs = [] - for list_ in expr_stmt.children[:-2:2]: - if list_.type in ('testlist_star_expr', 'testlist'): - exprs += _iter_definition_exprs_from_lists(list_) - else: - exprs.append(list_) - return exprs - - -def _get_for_stmt_definition_exprs(for_stmt): - exprlist = for_stmt.children[1] - if exprlist.type != 'exprlist': - return [exprlist] - return list(_iter_definition_exprs_from_lists(exprlist)) - - -class _Context(object): - def __init__(self, node, add_syntax_error, parent_context=None): - self.node = node - self.blocks = [] - self.parent_context = parent_context - self._used_name_dict = {} - self._global_names = [] - self._nonlocal_names = [] - self._nonlocal_names_in_subscopes = [] - self._add_syntax_error = add_syntax_error - - def is_async_funcdef(self): - # Stupidly enough async funcdefs can have two different forms, - # depending if a decorator is used or not. - return self.is_function() \ - and self.node.parent.type in ('async_funcdef', 'async_stmt') - - def is_function(self): - return self.node.type == 'funcdef' - - def add_name(self, name): - parent_type = name.parent.type - if parent_type == 'trailer': - # We are only interested in first level names. - return - - if parent_type == 'global_stmt': - self._global_names.append(name) - elif parent_type == 'nonlocal_stmt': - self._nonlocal_names.append(name) - else: - self._used_name_dict.setdefault(name.value, []).append(name) - - def finalize(self): - """ - Returns a list of nonlocal names that need to be part of that scope. - """ - self._analyze_names(self._global_names, 'global') - self._analyze_names(self._nonlocal_names, 'nonlocal') - - # Python2.6 doesn't have dict comprehensions. - global_name_strs = dict((n.value, n) for n in self._global_names) - for nonlocal_name in self._nonlocal_names: - try: - global_name = global_name_strs[nonlocal_name.value] - except KeyError: - continue - - message = "name '%s' is nonlocal and global" % global_name.value - if global_name.start_pos < nonlocal_name.start_pos: - error_name = global_name - else: - error_name = nonlocal_name - self._add_syntax_error(error_name, message) - - nonlocals_not_handled = [] - for nonlocal_name in self._nonlocal_names_in_subscopes: - search = nonlocal_name.value - if search in global_name_strs or self.parent_context is None: - message = "no binding for nonlocal '%s' found" % nonlocal_name.value - self._add_syntax_error(nonlocal_name, message) - elif not self.is_function() or \ - nonlocal_name.value not in self._used_name_dict: - nonlocals_not_handled.append(nonlocal_name) - return self._nonlocal_names + nonlocals_not_handled - - def _analyze_names(self, globals_or_nonlocals, type_): - def raise_(message): - self._add_syntax_error(base_name, message % (base_name.value, type_)) - - params = [] - if self.node.type == 'funcdef': - params = self.node.get_params() - - for base_name in globals_or_nonlocals: - found_global_or_nonlocal = False - # Somehow Python does it the reversed way. - for name in reversed(self._used_name_dict.get(base_name.value, [])): - if name.start_pos > base_name.start_pos: - # All following names don't have to be checked. - found_global_or_nonlocal = True - - parent = name.parent - if parent.type == 'param' and parent.name == name: - # Skip those here, these definitions belong to the next - # scope. - continue - - if name.is_definition(): - if parent.type == 'expr_stmt' \ - and parent.children[1].type == 'annassign': - if found_global_or_nonlocal: - # If it's after the global the error seems to be - # placed there. - base_name = name - raise_("annotated name '%s' can't be %s") - break - else: - message = "name '%s' is assigned to before %s declaration" - else: - message = "name '%s' is used prior to %s declaration" - - if not found_global_or_nonlocal: - raise_(message) - # Only add an error for the first occurence. - break - - for param in params: - if param.name.value == base_name.value: - raise_("name '%s' is parameter and %s"), - - @contextmanager - def add_block(self, node): - self.blocks.append(node) - yield - self.blocks.pop() - - def add_context(self, node): - return _Context(node, self._add_syntax_error, parent_context=self) - - def close_child_context(self, child_context): - self._nonlocal_names_in_subscopes += child_context.finalize() - - -class ErrorFinder(Normalizer): - """ - Searches for errors in the syntax tree. - """ - def __init__(self, *args, **kwargs): - super(ErrorFinder, self).__init__(*args, **kwargs) - self._error_dict = {} - self.version = self.grammar.version_info - - def initialize(self, node): - def create_context(node): - if node is None: - return None - - parent_context = create_context(node.parent) - if node.type in ('classdef', 'funcdef', 'file_input'): - return _Context(node, self._add_syntax_error, parent_context) - return parent_context - - self.context = create_context(node) or _Context(node, self._add_syntax_error) - self._indentation_count = 0 - - def visit(self, node): - if node.type == 'error_node': - with self.visit_node(node): - # Don't need to investigate the inners of an error node. We - # might find errors in there that should be ignored, because - # the error node itself already shows that there's an issue. - return '' - return super(ErrorFinder, self).visit(node) - - - @contextmanager - def visit_node(self, node): - self._check_type_rules(node) - - if node.type in _BLOCK_STMTS: - with self.context.add_block(node): - if len(self.context.blocks) == _MAX_BLOCK_SIZE: - self._add_syntax_error(node, "too many statically nested blocks") - yield - return - elif node.type == 'suite': - self._indentation_count += 1 - if self._indentation_count == _MAX_INDENT_COUNT: - self._add_indentation_error(node.children[1], "too many levels of indentation") - - yield - - if node.type == 'suite': - self._indentation_count -= 1 - elif node.type in ('classdef', 'funcdef'): - context = self.context - self.context = context.parent_context - self.context.close_child_context(context) - - def visit_leaf(self, leaf): - if leaf.type == 'error_leaf': - if leaf.original_type in ('indent', 'error_dedent'): - # Indents/Dedents itself never have a prefix. They are just - # "pseudo" tokens that get removed by the syntax tree later. - # Therefore in case of an error we also have to check for this. - spacing = list(leaf.get_next_leaf()._split_prefix())[-1] - if leaf.original_type == 'indent': - message = 'unexpected indent' - else: - message = 'unindent does not match any outer indentation level' - self._add_indentation_error(spacing, message) - else: - if leaf.value.startswith('\\'): - message = 'unexpected character after line continuation character' - else: - match = re.match('\\w{,2}("{1,3}|\'{1,3})', leaf.value) - if match is None: - message = 'invalid syntax' - else: - if len(match.group(1)) == 1: - message = 'EOL while scanning string literal' - else: - message = 'EOF while scanning triple-quoted string literal' - self._add_syntax_error(leaf, message) - return '' - elif leaf.value == ':': - parent = leaf.parent - if parent.type in ('classdef', 'funcdef'): - self.context = self.context.add_context(parent) - - # The rest is rule based. - return super(ErrorFinder, self).visit_leaf(leaf) - - def _add_indentation_error(self, spacing, message): - self.add_issue(spacing, 903, "IndentationError: " + message) - - def _add_syntax_error(self, node, message): - self.add_issue(node, 901, "SyntaxError: " + message) - - def add_issue(self, node, code, message): - # Overwrite the default behavior. - # Check if the issues are on the same line. - line = node.start_pos[0] - args = (code, message, node) - self._error_dict.setdefault(line, args) - - def finalize(self): - self.context.finalize() - - for code, message, node in self._error_dict.values(): - self.issues.append(Issue(node, code, message)) - - -class IndentationRule(Rule): - code = 903 - - def _get_message(self, message): - message = super(IndentationRule, self)._get_message(message) - return "IndentationError: " + message - - -@ErrorFinder.register_rule(type='error_node') -class _ExpectIndentedBlock(IndentationRule): - message = 'expected an indented block' - - def get_node(self, node): - leaf = node.get_next_leaf() - return list(leaf._split_prefix())[-1] - - def is_issue(self, node): - # This is the beginning of a suite that is not indented. - return node.children[-1].type == 'newline' - - -class ErrorFinderConfig(NormalizerConfig): - normalizer_class = ErrorFinder - - -class SyntaxRule(Rule): - code = 901 - - def _get_message(self, message): - message = super(SyntaxRule, self)._get_message(message) - return "SyntaxError: " + message - - -@ErrorFinder.register_rule(type='error_node') -class _InvalidSyntaxRule(SyntaxRule): - message = "invalid syntax" - - def get_node(self, node): - return node.get_next_leaf() - - def is_issue(self, node): - # Error leafs will be added later as an error. - return node.get_next_leaf().type != 'error_leaf' - - -@ErrorFinder.register_rule(value='await') -class _AwaitOutsideAsync(SyntaxRule): - message = "'await' outside async function" - - def is_issue(self, leaf): - return not self._normalizer.context.is_async_funcdef() - - def get_error_node(self, node): - # Return the whole await statement. - return node.parent - - -@ErrorFinder.register_rule(value='break') -class _BreakOutsideLoop(SyntaxRule): - message = "'break' outside loop" - - def is_issue(self, leaf): - in_loop = False - for block in self._normalizer.context.blocks: - if block.type in ('for_stmt', 'while_stmt'): - in_loop = True - return not in_loop - - -@ErrorFinder.register_rule(value='continue') -class _ContinueChecks(SyntaxRule): - message = "'continue' not properly in loop" - message_in_finally = "'continue' not supported inside 'finally' clause" - - def is_issue(self, leaf): - in_loop = False - for block in self._normalizer.context.blocks: - if block.type in ('for_stmt', 'while_stmt'): - in_loop = True - if block.type == 'try_stmt': - last_block = block.children[-3] - if last_block == 'finally' and leaf.start_pos > last_block.start_pos: - self.add_issue(leaf, message=self.message_in_finally) - return False # Error already added - if not in_loop: - return True - - -@ErrorFinder.register_rule(value='from') -class _YieldFromCheck(SyntaxRule): - message = "'yield from' inside async function" - - def get_node(self, leaf): - return leaf.parent.parent # This is the actual yield statement. - - def is_issue(self, leaf): - return leaf.parent.type == 'yield_arg' \ - and self._normalizer.context.is_async_funcdef() - - -@ErrorFinder.register_rule(type='name') -class _NameChecks(SyntaxRule): - message = 'cannot assign to __debug__' - message_keyword = 'assignment to keyword' - message_none = 'cannot assign to None' - - def is_issue(self, leaf): - self._normalizer.context.add_name(leaf) - - if leaf.value == '__debug__' and leaf.is_definition(): - if self._normalizer.version < (3, 0): - return True - else: - self.add_issue(leaf, message=self.message_keyword) - if leaf.value == 'None' and self._normalizer.version < (3, 0) \ - and leaf.is_definition(): - self.add_issue(leaf, message=self.message_none) - - -@ErrorFinder.register_rule(type='string') -class _StringChecks(SyntaxRule): - message = "bytes can only contain ASCII literal characters." - - def is_issue(self, leaf): - string_prefix = leaf.string_prefix.lower() - if 'b' in string_prefix \ - and self._normalizer.version >= (3, 0) \ - and any(c for c in leaf.value if ord(c) > 127): - # b'ä' - return True - - if 'r' not in string_prefix: - # Raw strings don't need to be checked if they have proper - # escaping. - is_bytes = self._normalizer.version < (3, 0) - if 'b' in string_prefix: - is_bytes = True - if 'u' in string_prefix: - is_bytes = False - - payload = leaf._get_payload() - if is_bytes: - payload = payload.encode('utf-8') - func = codecs.escape_decode - else: - func = codecs.unicode_escape_decode - - try: - with warnings.catch_warnings(): - # The warnings from parsing strings are not relevant. - warnings.filterwarnings('ignore') - func(payload) - except UnicodeDecodeError as e: - self.add_issue(leaf, message='(unicode error) ' + str(e)) - except ValueError as e: - self.add_issue(leaf, message='(value error) ' + str(e)) - - -@ErrorFinder.register_rule(value='*') -class _StarCheck(SyntaxRule): - message = "named arguments must follow bare *" - - def is_issue(self, leaf): - params = leaf.parent - if params.type == 'parameters' and params: - after = params.children[params.children.index(leaf) + 1:] - after = [child for child in after - if child not in (',', ')') and not child.star_count] - return len(after) == 0 - - -@ErrorFinder.register_rule(value='**') -class _StarStarCheck(SyntaxRule): - # e.g. {**{} for a in [1]} - # TODO this should probably get a better end_pos including - # the next sibling of leaf. - message = "dict unpacking cannot be used in dict comprehension" - - def is_issue(self, leaf): - if leaf.parent.type == 'dictorsetmaker': - comp_for = leaf.get_next_sibling().get_next_sibling() - return comp_for is not None and comp_for.type == 'comp_for' - - -@ErrorFinder.register_rule(value='yield') -@ErrorFinder.register_rule(value='return') -class _ReturnAndYieldChecks(SyntaxRule): - message = "'return' with value in async generator" - message_async_yield = "'yield' inside async function" - - def get_node(self, leaf): - return leaf.parent - - def is_issue(self, leaf): - if self._normalizer.context.node.type != 'funcdef': - self.add_issue(self.get_node(leaf), message="'%s' outside function" % leaf.value) - elif self._normalizer.context.is_async_funcdef() \ - and any(self._normalizer.context.node.iter_yield_exprs()): - if leaf.value == 'return' and leaf.parent.type == 'return_stmt': - return True - elif leaf.value == 'yield' \ - and leaf.get_next_leaf() != 'from' \ - and self._normalizer.version == (3, 5): - self.add_issue(self.get_node(leaf), message=self.message_async_yield) - -@ErrorFinder.register_rule(type='atom') -class _BytesAndStringMix(SyntaxRule): - # e.g. 's' b'' - message = "cannot mix bytes and nonbytes literals" - - def _is_bytes_literal(self, string): - return 'b' in string.string_prefix.lower() - - def is_issue(self, node): - first = node.children[0] - if first.type == 'string' and self._normalizer.version >= (3, 0): - first_is_bytes = self._is_bytes_literal(first) - for string in node.children[1:]: - if first_is_bytes != self._is_bytes_literal(string): - return True - - -@ErrorFinder.register_rule(type='import_as_names') -class _TrailingImportComma(SyntaxRule): - # e.g. from foo import a, - message = "trailing comma not allowed without surrounding parentheses" - - def is_issue(self, node): - if node.children[-1] == ',': - return True - - -@ErrorFinder.register_rule(type='import_from') -class _ImportStarInFunction(SyntaxRule): - message = "import * only allowed at module level" - - def is_issue(self, node): - return node.is_star_import() and self._normalizer.context.parent_context is not None - - -@ErrorFinder.register_rule(type='import_from') -class _FutureImportRule(SyntaxRule): - message = "from __future__ imports must occur at the beginning of the file" - - def is_issue(self, node): - if _is_future_import(node): - if not _is_future_import_first(node): - return True - - for from_name, future_name in node.get_paths(): - name = future_name.value - allowed_futures = list(ALLOWED_FUTURES) - if self._normalizer.version >= (3, 5): - allowed_futures.append('generator_stop') - - if name == 'braces': - self.add_issue(node, message = "not a chance") - elif name == 'barry_as_FLUFL': - m = "Seriously I'm not implementing this :) ~ Dave" - self.add_issue(node, message=m) - elif name not in ALLOWED_FUTURES: - message = "future feature %s is not defined" % name - self.add_issue(node, message=message) - - -@ErrorFinder.register_rule(type='star_expr') -class _StarExprRule(SyntaxRule): - message = "starred assignment target must be in a list or tuple" - message_iterable_unpacking = "iterable unpacking cannot be used in comprehension" - message_assignment = "can use starred expression only as assignment target" - - def is_issue(self, node): - if node.parent.type not in _STAR_EXPR_PARENTS: - return True - if node.parent.type == 'testlist_comp': - # [*[] for a in [1]] - if node.parent.children[1].type == 'comp_for': - self.add_issue(node, message=self.message_iterable_unpacking) - if self._normalizer.version <= (3, 4): - n = search_ancestor(node, 'for_stmt', 'expr_stmt') - found_definition = False - if n is not None: - if n.type == 'expr_stmt': - exprs = _get_expr_stmt_definition_exprs(n) - else: - exprs = _get_for_stmt_definition_exprs(n) - if node in exprs: - found_definition = True - - if not found_definition: - self.add_issue(node, message=self.message_assignment) - - -@ErrorFinder.register_rule(types=_STAR_EXPR_PARENTS) -class _StarExprParentRule(SyntaxRule): - def is_issue(self, node): - if node.parent.type == 'del_stmt': - self.add_issue(node.parent, message="can't use starred expression here") - else: - def is_definition(node, ancestor): - if ancestor is None: - return False - - type_ = ancestor.type - if type_ == 'trailer': - return False - - if type_ == 'expr_stmt': - return node.start_pos < ancestor.children[-1].start_pos - - return is_definition(node, ancestor.parent) - - if is_definition(node, node.parent): - args = [c for c in node.children if c != ','] - starred = [c for c in args if c.type == 'star_expr'] - if len(starred) > 1: - message = "two starred expressions in assignment" - self.add_issue(starred[1], message=message) - elif starred: - count = args.index(starred[0]) - if count >= 256: - message = "too many expressions in star-unpacking assignment" - self.add_issue(starred[0], message=message) - - -@ErrorFinder.register_rule(type='annassign') -class _AnnotatorRule(SyntaxRule): - # True: int - # {}: float - message = "illegal target for annotation" - - def get_node(self, node): - return node.parent - - def is_issue(self, node): - type_ = None - lhs = node.parent.children[0] - lhs = _remove_parens(lhs) - try: - children = lhs.children - except AttributeError: - pass - else: - if ',' in children or lhs.type == 'atom' and children[0] == '(': - type_ = 'tuple' - elif lhs.type == 'atom' and children[0] == '[': - type_ = 'list' - trailer = children[-1] - - if type_ is None: - if not (lhs.type == 'name' - # subscript/attributes are allowed - or lhs.type in ('atom_expr', 'power') - and trailer.type == 'trailer' - and trailer.children[0] != '('): - return True - else: - # x, y: str - message = "only single target (not %s) can be annotated" - self.add_issue(lhs.parent, message=message % type_) - - -@ErrorFinder.register_rule(type='argument') -class _ArgumentRule(SyntaxRule): - def is_issue(self, node): - first = node.children[0] - if node.children[1] == '=' and first.type != 'name': - if first.type == 'lambdef': - # f(lambda: 1=1) - message = "lambda cannot contain assignment" - else: - # f(+x=1) - message = "keyword can't be an expression" - self.add_issue(first, message=message) - - -@ErrorFinder.register_rule(type='nonlocal_stmt') -class _NonlocalModuleLevelRule(SyntaxRule): - message = "nonlocal declaration not allowed at module level" - - def is_issue(self, node): - return self._normalizer.context.parent_context is None - - -@ErrorFinder.register_rule(type='arglist') -class _ArglistRule(SyntaxRule): - message = "Generator expression must be parenthesized if not sole argument" - - def is_issue(self, node): - first_arg = node.children[0] - if first_arg.type == 'argument' \ - and first_arg.children[1].type == 'comp_for': - # e.g. foo(x for x in [], b) - return len(node.children) >= 2 - else: - arg_set = set() - kw_only = False - kw_unpacking_only = False - is_old_starred = False - # In python 3 this would be a bit easier (stars are part of - # argument), but we have to understand both. - for argument in node.children: - if argument == ',': - continue - - if argument in ('*', '**'): - # Python < 3.5 has the order engraved in the grammar - # file. No need to do anything here. - is_old_starred = True - continue - if is_old_starred: - is_old_starred = False - continue - - if argument.type == 'argument': - first = argument.children[0] - if first in ('*', '**'): - if first == '*': - if kw_unpacking_only: - # foo(**kwargs, *args) - message = "iterable argument unpacking follows keyword argument unpacking" - self.add_issue(argument, message=message) - else: - kw_unpacking_only = True - else: # Is a keyword argument. - kw_only = True - if first.type == 'name': - if first.value in arg_set: - # f(x=1, x=2) - self.add_issue(first, message="keyword argument repeated") - else: - arg_set.add(first.value) - else: - if kw_unpacking_only: - # f(**x, y) - message = "positional argument follows keyword argument unpacking" - self.add_issue(argument, message=message) - elif kw_only: - # f(x=2, y) - message = "positional argument follows keyword argument" - self.add_issue(argument, message=message) - -@ErrorFinder.register_rule(type='parameters') -@ErrorFinder.register_rule(type='lambdef') -class _ParameterRule(SyntaxRule): - # def f(x=3, y): pass - message = "non-default argument follows default argument" - - def is_issue(self, node): - param_names = set() - default_only = False - for p in _iter_params(node): - if p.name.value in param_names: - message = "duplicate argument '%s' in function definition" - self.add_issue(p.name, message=message % p.name.value) - param_names.add(p.name.value) - - if p.default is None and not p.star_count: - if default_only: - return True - else: - default_only = True - - -@ErrorFinder.register_rule(type='try_stmt') -class _TryStmtRule(SyntaxRule): - message = "default 'except:' must be last" - - def is_issue(self, try_stmt): - default_except = None - for except_clause in try_stmt.children[3::3]: - if except_clause in ('else', 'finally'): - break - if except_clause == 'except': - default_except = except_clause - elif default_except is not None: - self.add_issue(default_except, message=self.message) - - -@ErrorFinder.register_rule(type='string') -class _FStringRule(SyntaxRule): - _fstring_grammar = None - message_empty = "f-string: empty expression not allowed" # f'{}' - message_single_closing = "f-string: single '}' is not allowed" # f'}' - message_nested = "f-string: expressions nested too deeply" - message_backslash = "f-string expression part cannot include a backslash" # f'{"\"}' or f'{"\\"}' - message_comment = "f-string expression part cannot include '#'" # f'{#}' - message_unterminated_string = "f-string: unterminated string" # f'{"}' - message_conversion = "f-string: invalid conversion character: expected 's', 'r', or 'a'" - message_incomplete = "f-string: expecting '}'" # f'{' - message_syntax = "invalid syntax" - - @classmethod - def _load_grammar(cls): - import parso - - if cls._fstring_grammar is None: - cls._fstring_grammar = parso.load_grammar(language='python-f-string') - return cls._fstring_grammar - - def is_issue(self, fstring): - if 'f' not in fstring.string_prefix.lower(): - return - - parsed = self._load_grammar().parse_leaf(fstring) - for child in parsed.children: - if child.type == 'expression': - self._check_expression(child) - elif child.type == 'error_node': - next_ = child.get_next_leaf() - if next_.type == 'error_leaf' and next_.original_type == 'unterminated_string': - self.add_issue(next_, message=self.message_unterminated_string) - # At this point nothing more is comming except the error - # leaf that we've already checked here. - break - self.add_issue(child, message=self.message_incomplete) - elif child.type == 'error_leaf': - self.add_issue(child, message=self.message_single_closing) - - def _check_python_expr(self, python_expr): - value = python_expr.value - if '\\' in value: - self.add_issue(python_expr, message=self.message_backslash) - return - if '#' in value: - self.add_issue(python_expr, message=self.message_comment) - return - if re.match('\s*$', value) is not None: - self.add_issue(python_expr, message=self.message_empty) - return - - # This is now nested parsing. We parsed the fstring and now - # we're parsing Python again. - try: - # CPython has a bit of a special ways to parse Python code within - # f-strings. It wraps the code in brackets to make sure that - # whitespace doesn't make problems (indentation/newlines). - # Just use that algorithm as well here and adapt start positions. - start_pos = python_expr.start_pos - start_pos = start_pos[0], start_pos[1] - 1 - eval_input = self._normalizer.grammar._parse( - '(%s)' % value, - start_symbol='eval_input', - start_pos=start_pos, - error_recovery=False - ) - except ParserSyntaxError as e: - self.add_issue(e.error_leaf, message=self.message_syntax) - return - - issues = self._normalizer.grammar.iter_errors(eval_input) - self._normalizer.issues += issues - - def _check_format_spec(self, format_spec): - for expression in format_spec.children[1:]: - nested_format_spec = expression.children[-2] - if nested_format_spec.type == 'format_spec': - if len(nested_format_spec.children) > 1: - self.add_issue( - nested_format_spec.children[1], - message=self.message_nested - ) - - self._check_expression(expression) - - def _check_expression(self, expression): - for c in expression.children: - if c.type == 'python_expr': - self._check_python_expr(c) - elif c.type == 'conversion': - if c.value not in ('s', 'r', 'a'): - self.add_issue(c, message=self.message_conversion) - elif c.type == 'format_spec': - self._check_format_spec(c) - - -class _CheckAssignmentRule(SyntaxRule): - def _check_assignment(self, node, is_deletion=False): - error = None - type_ = node.type - if type_ == 'lambdef': - error = 'lambda' - elif type_ == 'atom': - first, second = node.children[:2] - error = _get_comprehension_type(node) - if error is None: - if second.type in ('dictorsetmaker', 'string'): - error = 'literal' - elif first in ('(', '['): - if second.type == 'yield_expr': - error = 'yield expression' - elif second.type == 'testlist_comp': - # This is not a comprehension, they were handled - # further above. - for child in second.children[::2]: - self._check_assignment(child, is_deletion) - else: # Everything handled, must be useless brackets. - self._check_assignment(second, is_deletion) - elif type_ == 'keyword': - error = 'keyword' - elif type_ == 'operator': - if node.value == '...': - error = 'Ellipsis' - elif type_ == 'comparison': - error = 'comparison' - elif type_ in ('string', 'number'): - error = 'literal' - elif type_ == 'yield_expr': - # This one seems to be a slightly different warning in Python. - message = 'assignment to yield expression not possible' - self.add_issue(node, message=message) - elif type_ == 'test': - error = 'conditional expression' - elif type_ in ('atom_expr', 'power'): - if node.children[0] == 'await': - error = 'await expression' - elif node.children[-2] == '**': - error = 'operator' - else: - # Has a trailer - trailer = node.children[-1] - assert trailer.type == 'trailer' - if trailer.children[0] == '(': - error = 'function call' - elif type_ in ('testlist_star_expr', 'exprlist', 'testlist'): - for child in node.children[::2]: - self._check_assignment(child, is_deletion) - elif ('expr' in type_ and type_ != 'star_expr' # is a substring - or '_test' in type_ - or type_ in ('term', 'factor')): - error = 'operator' - - if error is not None: - message = "can't %s %s" % ("delete" if is_deletion else "assign to", error) - self.add_issue(node, message=message) - - -@ErrorFinder.register_rule(type='comp_for') -class _CompForRule(_CheckAssignmentRule): - message = "asynchronous comprehension outside of an asynchronous function" - - def is_issue(self, node): - # Some of the nodes here are already used, so no else if - expr_list = node.children[1 + int(node.children[0] == 'async')] - if expr_list.type != 'expr_list': # Already handled. - self._check_assignment(expr_list) - - return node.children[0] == 'async' \ - and not self._normalizer.context.is_async_funcdef() - - -@ErrorFinder.register_rule(type='expr_stmt') -class _ExprStmtRule(_CheckAssignmentRule): - message = "illegal expression for augmented assignment" - - def is_issue(self, node): - for before_equal in node.children[:-2:2]: - self._check_assignment(before_equal) - - augassign = node.children[1] - if augassign != '=' and augassign.type != 'annassign': # Is augassign. - return node.children[0].type in ('testlist_star_expr', 'atom', 'testlist') - - -@ErrorFinder.register_rule(type='with_item') -class _WithItemRule(_CheckAssignmentRule): - def is_issue(self, with_item): - self._check_assignment(with_item.children[2]) - - -@ErrorFinder.register_rule(type='del_stmt') -class _DelStmtRule(_CheckAssignmentRule): - def is_issue(self, del_stmt): - child = del_stmt.children[1] - - if child.type != 'expr_list': # Already handled. - self._check_assignment(child, is_deletion=True) - - -@ErrorFinder.register_rule(type='expr_list') -class _ExprListRule(_CheckAssignmentRule): - def is_issue(self, expr_list): - for expr in expr_list.children[::2]: - self._check_assignment(expr) - - -@ErrorFinder.register_rule(type='for_stmt') -class _ForStmtRule(_CheckAssignmentRule): - def is_issue(self, for_stmt): - # Some of the nodes here are already used, so no else if - expr_list = for_stmt.children[1] - if expr_list.type != 'expr_list': # Already handled. - self._check_assignment(expr_list) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/fstring.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/fstring.py deleted file mode 100644 index a8fe7b4..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/fstring.py +++ /dev/null @@ -1,211 +0,0 @@ -import re - -from itertools import count -from parso.utils import PythonVersionInfo -from parso.utils import split_lines -from parso.python.tokenize import Token -from parso import parser -from parso.tree import TypedLeaf, ErrorNode, ErrorLeaf - -version36 = PythonVersionInfo(3, 6) - - -class TokenNamespace: - _c = count() - LBRACE = next(_c) - RBRACE = next(_c) - ENDMARKER = next(_c) - COLON = next(_c) - CONVERSION = next(_c) - PYTHON_EXPR = next(_c) - EXCLAMATION_MARK = next(_c) - UNTERMINATED_STRING = next(_c) - - token_map = dict((v, k) for k, v in locals().items() if not k.startswith('_')) - - @classmethod - def generate_token_id(cls, string): - if string == '{': - return cls.LBRACE - elif string == '}': - return cls.RBRACE - elif string == '!': - return cls.EXCLAMATION_MARK - elif string == ':': - return cls.COLON - return getattr(cls, string) - - -GRAMMAR = """ -fstring: expression* ENDMARKER -format_spec: ':' expression* -expression: '{' PYTHON_EXPR [ '!' CONVERSION ] [ format_spec ] '}' -""" - -_prefix = r'((?:[^{}]+)*)' -_expr = _prefix + r'(\{|\}|$)' -_in_expr = r'([^{}\[\]:"\'!]*)(.?)' -# There's only one conversion character allowed. But the rules have to be -# checked later anyway, so allow more here. This makes error recovery nicer. -_conversion = r'([^={}:]*)(.?)' - -_compiled_expr = re.compile(_expr) -_compiled_in_expr = re.compile(_in_expr) -_compiled_conversion = re.compile(_conversion) - - -def tokenize(code, start_pos=(1, 0)): - def add_to_pos(string): - lines = split_lines(string) - l = len(lines[-1]) - if len(lines) > 1: - start_pos[0] += len(lines) - 1 - start_pos[1] = l - else: - start_pos[1] += l - - def tok(value, type=None, prefix=''): - if type is None: - type = TokenNamespace.generate_token_id(value) - - add_to_pos(prefix) - token = Token(type, value, tuple(start_pos), prefix) - add_to_pos(value) - return token - - start = 0 - recursion_level = 0 - added_prefix = '' - start_pos = list(start_pos) - while True: - match = _compiled_expr.match(code, start) - prefix = added_prefix + match.group(1) - found = match.group(2) - start = match.end() - if not found: - # We're at the end. - break - - if found == '}': - if recursion_level == 0 and len(code) > start and code[start] == '}': - # This is a }} escape. - added_prefix = prefix + '}}' - start += 1 - continue - - recursion_level = max(0, recursion_level - 1) - yield tok(found, prefix=prefix) - added_prefix = '' - else: - assert found == '{' - if recursion_level == 0 and len(code) > start and code[start] == '{': - # This is a {{ escape. - added_prefix = prefix + '{{' - start += 1 - continue - - recursion_level += 1 - yield tok(found, prefix=prefix) - added_prefix = '' - - expression = '' - squared_count = 0 - curly_count = 0 - while True: - expr_match = _compiled_in_expr.match(code, start) - expression += expr_match.group(1) - found = expr_match.group(2) - start = expr_match.end() - - if found == '{': - curly_count += 1 - expression += found - elif found == '}' and curly_count > 0: - curly_count -= 1 - expression += found - elif found == '[': - squared_count += 1 - expression += found - elif found == ']': - # Use a max function here, because the Python code might - # just have syntax errors. - squared_count = max(0, squared_count - 1) - expression += found - elif found == ':' and (squared_count or curly_count): - expression += found - elif found in ('"', "'"): - search = found - if len(code) > start + 1 and \ - code[start] == found == code[start+1]: - search *= 3 - start += 2 - - index = code.find(search, start) - if index == -1: - yield tok(expression, type=TokenNamespace.PYTHON_EXPR) - yield tok( - found + code[start:], - type=TokenNamespace.UNTERMINATED_STRING, - ) - start = len(code) - break - expression += found + code[start:index+1] - start = index + 1 - elif found == '!' and len(code) > start and code[start] == '=': - # This is a python `!=` and not a conversion. - expression += found - else: - yield tok(expression, type=TokenNamespace.PYTHON_EXPR) - if found: - yield tok(found) - break - - if found == '!': - conversion_match = _compiled_conversion.match(code, start) - found = conversion_match.group(2) - start = conversion_match.end() - yield tok(conversion_match.group(1), type=TokenNamespace.CONVERSION) - if found: - yield tok(found) - if found == '}': - recursion_level -= 1 - - # We don't need to handle everything after ':', because that is - # basically new tokens. - - yield tok('', type=TokenNamespace.ENDMARKER, prefix=prefix) - - -class Parser(parser.BaseParser): - def parse(self, tokens): - node = super(Parser, self).parse(tokens) - if isinstance(node, self.default_leaf): # Is an endmarker. - # If there's no curly braces we get back a non-module. We always - # want an fstring. - node = self.default_node('fstring', [node]) - - return node - - def convert_leaf(self, pgen_grammar, type, value, prefix, start_pos): - # TODO this is so ugly. - leaf_type = TokenNamespace.token_map[type].lower() - return TypedLeaf(leaf_type, value, start_pos, prefix) - - def error_recovery(self, pgen_grammar, stack, arcs, typ, value, start_pos, prefix, - add_token_callback): - if not self._error_recovery: - return super(Parser, self).error_recovery( - pgen_grammar, stack, arcs, typ, value, start_pos, prefix, - add_token_callback - ) - - token_type = TokenNamespace.token_map[typ].lower() - if len(stack) == 1: - error_leaf = ErrorLeaf(token_type, value, start_pos, prefix) - stack[0][2][1].append(error_leaf) - else: - dfa, state, (type_, nodes) = stack[1] - stack[0][2][1].append(ErrorNode(nodes)) - stack[1:] = [] - - add_token_callback(typ, value, start_pos, prefix) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar26.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar26.txt deleted file mode 100644 index b972a41..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar26.txt +++ /dev/null @@ -1,158 +0,0 @@ -# Grammar for Python - -# Note: Changing the grammar specified in this file will most likely -# require corresponding changes in the parser module -# (../Modules/parsermodule.c). If you can't make the changes to -# that module yourself, please co-ordinate the required changes -# with someone who can; ask around on python-dev for help. Fred -# Drake will probably be listening there. - -# NOTE WELL: You should also follow all the steps listed in PEP 306, -# "How to Change Python's Grammar" - -# Commands for Kees Blom's railroad program -#diagram:token NAME -#diagram:token NUMBER -#diagram:token STRING -#diagram:token NEWLINE -#diagram:token ENDMARKER -#diagram:token INDENT -#diagram:output\input python.bla -#diagram:token DEDENT -#diagram:output\textwidth 20.04cm\oddsidemargin 0.0cm\evensidemargin 0.0cm -#diagram:rules - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() and input() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER - -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef) -funcdef: 'def' NAME parameters ':' suite -parameters: '(' [varargslist] ')' -varargslist: ((fpdef ['=' test] ',')* - ('*' NAME [',' '**' NAME] | '**' NAME) | - fpdef ['=' test] (',' fpdef ['=' test])* [',']) -fpdef: NAME | '(' fplist ')' -fplist: fpdef (',' fpdef)* [','] - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | exec_stmt | assert_stmt) -expr_stmt: testlist (augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist))*) -augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal assignments, additional restrictions enforced by the interpreter -print_stmt: 'print' ( [ test (',' test)* [','] ] | - '>>' test [ (',' test)+ [','] ] ) -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test [',' test [',' test]]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -import_from: ('from' ('.'* dotted_name | '.'+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -exec_stmt: 'exec' expr ['in' test [',' test]] -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item ':' suite -# Dave: Python2.6 actually defines a little bit of a different label called -# 'with_var'. However in 2.7+ this is the default. Apply it for -# consistency reasons. -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test [('as' | ',') test]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -# Backward compatibility cruft to support: -# [ x for x in lambda: True, lambda: False if x() ] -# even while also allowing: -# lambda x: 5 if x else 2 -# (But not a mix of the two) -testlist_safe: old_test [(',' old_test)+ [',']] -old_test: or_test | old_lambdef -old_lambdef: 'lambda' [varargslist] ':' old_test - -test: or_test ['if' or_test 'else' test] | lambdef -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom trailer* ['**' factor] -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [listmaker] ']' | - '{' [dictorsetmaker] '}' | - '`' testlist1 '`' | - NAME | NUMBER | STRING+) -listmaker: test ( list_for | (',' test)* [','] ) -# Dave: Renamed testlist_gexpr to testlist_comp, because in 2.7+ this is the -# default. It's more consistent like this. -testlist_comp: test ( gen_for | (',' test)* [','] ) -lambdef: 'lambda' [varargslist] ':' test -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: expr (',' expr)* [','] -testlist: test (',' test)* [','] -# Dave: Rename from dictmaker to dictorsetmaker, because this is more -# consistent with the following grammars. -dictorsetmaker: test ':' test (',' test ':' test)* [','] - -classdef: 'class' NAME ['(' [testlist] ')'] ':' suite - -arglist: (argument ',')* (argument [','] - |'*' test (',' argument)* [',' '**' test] - |'**' test) -argument: test [gen_for] | test '=' test # Really [keyword '='] test - -list_iter: list_for | list_if -list_for: 'for' exprlist 'in' testlist_safe [list_iter] -list_if: 'if' old_test [list_iter] - -gen_iter: gen_for | gen_if -gen_for: 'for' exprlist 'in' or_test [gen_iter] -gen_if: 'if' old_test [gen_iter] - -testlist1: test (',' test)* - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [testlist] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar27.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar27.txt deleted file mode 100644 index 4c3f33d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar27.txt +++ /dev/null @@ -1,142 +0,0 @@ -# Grammar for Python - -# Note: Changing the grammar specified in this file will most likely -# require corresponding changes in the parser module -# (../Modules/parsermodule.c). If you can't make the changes to -# that module yourself, please co-ordinate the required changes -# with someone who can; ask around on python-dev for help. Fred -# Drake will probably be listening there. - -# NOTE WELL: You should also follow all the steps listed in PEP 306, -# "How to Change Python's Grammar" - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() and input() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER - -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef) -funcdef: 'def' NAME parameters ':' suite -parameters: '(' [varargslist] ')' -varargslist: ((fpdef ['=' test] ',')* - ('*' NAME [',' '**' NAME] | '**' NAME) | - fpdef ['=' test] (',' fpdef ['=' test])* [',']) -fpdef: NAME | '(' fplist ')' -fplist: fpdef (',' fpdef)* [','] - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | print_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | exec_stmt | assert_stmt) -expr_stmt: testlist (augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist))*) -augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal assignments, additional restrictions enforced by the interpreter -print_stmt: 'print' ( [ test (',' test)* [','] ] | - '>>' test [ (',' test)+ [','] ] ) -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test [',' test [',' test]]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -import_from: ('from' ('.'* dotted_name | '.'+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -exec_stmt: 'exec' expr ['in' test [',' test]] -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test [('as' | ',') test]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -# Backward compatibility cruft to support: -# [ x for x in lambda: True, lambda: False if x() ] -# even while also allowing: -# lambda x: 5 if x else 2 -# (But not a mix of the two) -testlist_safe: old_test [(',' old_test)+ [',']] -old_test: or_test | old_lambdef -old_lambdef: 'lambda' [varargslist] ':' old_test - -test: or_test ['if' or_test 'else' test] | lambdef -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom trailer* ['**' factor] -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [listmaker] ']' | - '{' [dictorsetmaker] '}' | - '`' testlist1 '`' | - NAME | NUMBER | STRING+) -listmaker: test ( list_for | (',' test)* [','] ) -testlist_comp: test ( comp_for | (',' test)* [','] ) -lambdef: 'lambda' [varargslist] ':' test -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: '.' '.' '.' | test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: expr (',' expr)* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) | - (test (comp_for | (',' test)* [','])) ) - -classdef: 'class' NAME ['(' [testlist] ')'] ':' suite - -arglist: (argument ',')* (argument [','] - |'*' test (',' argument)* [',' '**' test] - |'**' test) -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -argument: test [comp_for] | test '=' test - -list_iter: list_for | list_if -list_for: 'for' exprlist 'in' testlist_safe [list_iter] -list_if: 'if' old_test [list_iter] - -comp_iter: comp_for | comp_if -comp_for: 'for' exprlist 'in' or_test [comp_iter] -comp_if: 'if' old_test [comp_iter] - -testlist1: test (',' test)* - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [testlist] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar33.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar33.txt deleted file mode 100644 index d7aaffd..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar33.txt +++ /dev/null @@ -1,133 +0,0 @@ -# Grammar for Python - -# Note: Changing the grammar specified in this file will most likely -# require corresponding changes in the parser module -# (../Modules/parsermodule.c). If you can't make the changes to -# that module yourself, please co-ordinate the required changes -# with someone who can; ask around on python-dev for help. Fred -# Drake will probably be listening there. - -# NOTE WELL: You should also follow all the steps listed in PEP 306, -# "How to Change Python's Grammar" - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER - -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef) -funcdef: 'def' NAME parameters ['->' test] ':' suite -parameters: '(' [typedargslist] ')' -typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' - ['*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef]] - | '*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef) -tfpdef: NAME [':' test] -varargslist: (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' - ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef) -vfpdef: NAME - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt) -expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist_star_expr))*) -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test ['from' test]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -nonlocal_stmt: 'nonlocal' NAME (',' NAME)* -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test ['as' NAME]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -test: or_test ['if' or_test 'else' test] | lambdef -test_nocond: or_test | lambdef_nocond -lambdef: 'lambda' [varargslist] ':' test -lambdef_nocond: 'lambda' [varargslist] ':' test_nocond -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -# <> isn't actually a valid comparison operator in Python. It's here for the -# sake of a __future__ import described in PEP 401 -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -star_expr: '*' expr -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom trailer* ['**' factor] -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [testlist_comp] ']' | - '{' [dictorsetmaker] '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False') -testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] ) -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) | - (test (comp_for | (',' test)* [','])) ) - -classdef: 'class' NAME ['(' [arglist] ')'] ':' suite - -arglist: (argument ',')* (argument [','] - |'*' test (',' argument)* [',' '**' test] - |'**' test) -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -argument: test [comp_for] | test '=' test # Really [keyword '='] test -comp_iter: comp_for | comp_if -comp_for: 'for' exprlist 'in' or_test [comp_iter] -comp_if: 'if' test_nocond [comp_iter] - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [yield_arg] -yield_arg: 'from' test | testlist diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar34.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar34.txt deleted file mode 100644 index 05c3181..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar34.txt +++ /dev/null @@ -1,133 +0,0 @@ -# Grammar for Python - -# Note: Changing the grammar specified in this file will most likely -# require corresponding changes in the parser module -# (../Modules/parsermodule.c). If you can't make the changes to -# that module yourself, please co-ordinate the required changes -# with someone who can; ask around on python-dev for help. Fred -# Drake will probably be listening there. - -# NOTE WELL: You should also follow all the steps listed at -# https://docs.python.org/devguide/grammar.html - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER - -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef) -funcdef: 'def' NAME parameters ['->' test] ':' suite -parameters: '(' [typedargslist] ')' -typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' - ['*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef]] - | '*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef) -tfpdef: NAME [':' test] -varargslist: (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' - ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef) -vfpdef: NAME - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt) -expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist_star_expr))*) -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -augassign: ('+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test ['from' test]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -nonlocal_stmt: 'nonlocal' NAME (',' NAME)* -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test ['as' NAME]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -test: or_test ['if' or_test 'else' test] | lambdef -test_nocond: or_test | lambdef_nocond -lambdef: 'lambda' [varargslist] ':' test -lambdef_nocond: 'lambda' [varargslist] ':' test_nocond -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -# <> isn't actually a valid comparison operator in Python. It's here for the -# sake of a __future__ import described in PEP 401 -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -star_expr: '*' expr -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom trailer* ['**' factor] -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [testlist_comp] ']' | - '{' [dictorsetmaker] '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False') -testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] ) -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( (test ':' test (comp_for | (',' test ':' test)* [','])) | - (test (comp_for | (',' test)* [','])) ) - -classdef: 'class' NAME ['(' [arglist] ')'] ':' suite - -arglist: (argument ',')* (argument [','] - |'*' test (',' argument)* [',' '**' test] - |'**' test) -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -argument: test [comp_for] | test '=' test # Really [keyword '='] test -comp_iter: comp_for | comp_if -comp_for: 'for' exprlist 'in' or_test [comp_iter] -comp_if: 'if' test_nocond [comp_iter] - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [yield_arg] -yield_arg: 'from' test | testlist diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar35.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar35.txt deleted file mode 100644 index c38217f..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar35.txt +++ /dev/null @@ -1,152 +0,0 @@ -# Grammar for Python - -# Note: Changing the grammar specified in this file will most likely -# require corresponding changes in the parser module -# (../Modules/parsermodule.c). If you can't make the changes to -# that module yourself, please co-ordinate the required changes -# with someone who can; ask around on python-dev for help. Fred -# Drake will probably be listening there. - -# NOTE WELL: You should also follow all the steps listed at -# https://docs.python.org/devguide/grammar.html - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER - -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef | async_funcdef) - -# NOTE: Reinoud Elhorst, using ASYNC/AWAIT keywords instead of tokens -# skipping python3.5 compatibility, in favour of 3.7 solution -async_funcdef: 'async' funcdef -funcdef: 'def' NAME parameters ['->' test] ':' suite - -parameters: '(' [typedargslist] ')' -typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' - ['*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef]] - | '*' [tfpdef] (',' tfpdef ['=' test])* [',' '**' tfpdef] | '**' tfpdef) -tfpdef: NAME [':' test] -varargslist: (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' - ['*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' '**' vfpdef] | '**' vfpdef) -vfpdef: NAME - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt) -expr_stmt: testlist_star_expr (augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist_star_expr))*) -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test ['from' test]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -nonlocal_stmt: 'nonlocal' NAME (',' NAME)* -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt -async_stmt: 'async' (funcdef | with_stmt | for_stmt) -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test ['as' NAME]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -test: or_test ['if' or_test 'else' test] | lambdef -test_nocond: or_test | lambdef_nocond -lambdef: 'lambda' [varargslist] ':' test -lambdef_nocond: 'lambda' [varargslist] ':' test_nocond -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -# <> isn't actually a valid comparison operator in Python. It's here for the -# sake of a __future__ import described in PEP 401 (which really works :-) -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -star_expr: '*' expr -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'@'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom_expr ['**' factor] -atom_expr: ['await'] atom trailer* -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [testlist_comp] ']' | - '{' [dictorsetmaker] '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False') -testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] ) -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( ((test ':' test | '**' expr) - (comp_for | (',' (test ':' test | '**' expr))* [','])) | - ((test | star_expr) - (comp_for | (',' (test | star_expr))* [','])) ) - -classdef: 'class' NAME ['(' [arglist] ')'] ':' suite - -arglist: argument (',' argument)* [','] - -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -# "test '=' test" is really "keyword '=' test", but we have no such token. -# These need to be in a single rule to avoid grammar that is ambiguous -# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, -# we explicitly match '*' here, too, to give it proper precedence. -# Illegal combinations and orderings are blocked in ast.c: -# multiple (test comp_for) arguments are blocked; keyword unpackings -# that precede iterable unpackings are blocked; etc. -argument: ( test [comp_for] | - test '=' test | - '**' test | - '*' test ) - -comp_iter: comp_for | comp_if -comp_for: 'for' exprlist 'in' or_test [comp_iter] -comp_if: 'if' test_nocond [comp_iter] - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [yield_arg] -yield_arg: 'from' test | testlist diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar36.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar36.txt deleted file mode 100644 index e76147e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar36.txt +++ /dev/null @@ -1,150 +0,0 @@ -# Grammar for Python - -# NOTE WELL: You should also follow all the steps listed at -# https://docs.python.org/devguide/grammar.html - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef | async_funcdef) - -# NOTE: Francisco Souza/Reinoud Elhorst, using ASYNC/'await' keywords instead of -# skipping python3.5+ compatibility, in favour of 3.7 solution -async_funcdef: 'async' funcdef -funcdef: 'def' NAME parameters ['->' test] ':' suite - -parameters: '(' [typedargslist] ')' -typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' [ - '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] - | '**' tfpdef [',']]] - | '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] - | '**' tfpdef [',']) -tfpdef: NAME [':' test] -varargslist: (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ - '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [',']]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [','] -) -vfpdef: NAME - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt) -expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist_star_expr))*) -annassign: ':' test ['=' test] -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal and annotated assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test ['from' test]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -nonlocal_stmt: 'nonlocal' NAME (',' NAME)* -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt -async_stmt: 'async' (funcdef | with_stmt | for_stmt) -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test ['as' NAME]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -test: or_test ['if' or_test 'else' test] | lambdef -test_nocond: or_test | lambdef_nocond -lambdef: 'lambda' [varargslist] ':' test -lambdef_nocond: 'lambda' [varargslist] ':' test_nocond -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -# <> isn't actually a valid comparison operator in Python. It's here for the -# sake of a __future__ import described in PEP 401 (which really works :-) -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -star_expr: '*' expr -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'@'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom_expr ['**' factor] -atom_expr: ['await'] atom trailer* -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [testlist_comp] ']' | - '{' [dictorsetmaker] '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False') -testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] ) -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( ((test ':' test | '**' expr) - (comp_for | (',' (test ':' test | '**' expr))* [','])) | - ((test | star_expr) - (comp_for | (',' (test | star_expr))* [','])) ) - -classdef: 'class' NAME ['(' [arglist] ')'] ':' suite - -arglist: argument (',' argument)* [','] - -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -# "test '=' test" is really "keyword '=' test", but we have no such token. -# These need to be in a single rule to avoid grammar that is ambiguous -# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, -# we explicitly match '*' here, too, to give it proper precedence. -# Illegal combinations and orderings are blocked in ast.c: -# multiple (test comp_for) arguments are blocked; keyword unpackings -# that precede iterable unpackings are blocked; etc. -argument: ( test [comp_for] | - test '=' test | - '**' test | - '*' test ) - -comp_iter: comp_for | comp_if -comp_for: ['async'] 'for' exprlist 'in' or_test [comp_iter] -comp_if: 'if' test_nocond [comp_iter] - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [yield_arg] -yield_arg: 'from' test | testlist diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar37.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar37.txt deleted file mode 100644 index e76147e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/grammar37.txt +++ /dev/null @@ -1,150 +0,0 @@ -# Grammar for Python - -# NOTE WELL: You should also follow all the steps listed at -# https://docs.python.org/devguide/grammar.html - -# Start symbols for the grammar: -# single_input is a single interactive statement; -# file_input is a module or sequence of commands read from an input file; -# eval_input is the input for the eval() functions. -# NB: compound_stmt in single_input is followed by extra NEWLINE! -single_input: NEWLINE | simple_stmt | compound_stmt NEWLINE -file_input: (NEWLINE | stmt)* ENDMARKER -eval_input: testlist NEWLINE* ENDMARKER -decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE -decorators: decorator+ -decorated: decorators (classdef | funcdef | async_funcdef) - -# NOTE: Francisco Souza/Reinoud Elhorst, using ASYNC/'await' keywords instead of -# skipping python3.5+ compatibility, in favour of 3.7 solution -async_funcdef: 'async' funcdef -funcdef: 'def' NAME parameters ['->' test] ':' suite - -parameters: '(' [typedargslist] ')' -typedargslist: (tfpdef ['=' test] (',' tfpdef ['=' test])* [',' [ - '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] - | '**' tfpdef [',']]] - | '*' [tfpdef] (',' tfpdef ['=' test])* [',' ['**' tfpdef [',']]] - | '**' tfpdef [',']) -tfpdef: NAME [':' test] -varargslist: (vfpdef ['=' test] (',' vfpdef ['=' test])* [',' [ - '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [',']]] - | '*' [vfpdef] (',' vfpdef ['=' test])* [',' ['**' vfpdef [',']]] - | '**' vfpdef [','] -) -vfpdef: NAME - -stmt: simple_stmt | compound_stmt -simple_stmt: small_stmt (';' small_stmt)* [';'] NEWLINE -small_stmt: (expr_stmt | del_stmt | pass_stmt | flow_stmt | - import_stmt | global_stmt | nonlocal_stmt | assert_stmt) -expr_stmt: testlist_star_expr (annassign | augassign (yield_expr|testlist) | - ('=' (yield_expr|testlist_star_expr))*) -annassign: ':' test ['=' test] -testlist_star_expr: (test|star_expr) (',' (test|star_expr))* [','] -augassign: ('+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | - '<<=' | '>>=' | '**=' | '//=') -# For normal and annotated assignments, additional restrictions enforced by the interpreter -del_stmt: 'del' exprlist -pass_stmt: 'pass' -flow_stmt: break_stmt | continue_stmt | return_stmt | raise_stmt | yield_stmt -break_stmt: 'break' -continue_stmt: 'continue' -return_stmt: 'return' [testlist] -yield_stmt: yield_expr -raise_stmt: 'raise' [test ['from' test]] -import_stmt: import_name | import_from -import_name: 'import' dotted_as_names -# note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS -import_from: ('from' (('.' | '...')* dotted_name | ('.' | '...')+) - 'import' ('*' | '(' import_as_names ')' | import_as_names)) -import_as_name: NAME ['as' NAME] -dotted_as_name: dotted_name ['as' NAME] -import_as_names: import_as_name (',' import_as_name)* [','] -dotted_as_names: dotted_as_name (',' dotted_as_name)* -dotted_name: NAME ('.' NAME)* -global_stmt: 'global' NAME (',' NAME)* -nonlocal_stmt: 'nonlocal' NAME (',' NAME)* -assert_stmt: 'assert' test [',' test] - -compound_stmt: if_stmt | while_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated | async_stmt -async_stmt: 'async' (funcdef | with_stmt | for_stmt) -if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite] -while_stmt: 'while' test ':' suite ['else' ':' suite] -for_stmt: 'for' exprlist 'in' testlist ':' suite ['else' ':' suite] -try_stmt: ('try' ':' suite - ((except_clause ':' suite)+ - ['else' ':' suite] - ['finally' ':' suite] | - 'finally' ':' suite)) -with_stmt: 'with' with_item (',' with_item)* ':' suite -with_item: test ['as' expr] -# NB compile.c makes sure that the default except clause is last -except_clause: 'except' [test ['as' NAME]] -suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT - -test: or_test ['if' or_test 'else' test] | lambdef -test_nocond: or_test | lambdef_nocond -lambdef: 'lambda' [varargslist] ':' test -lambdef_nocond: 'lambda' [varargslist] ':' test_nocond -or_test: and_test ('or' and_test)* -and_test: not_test ('and' not_test)* -not_test: 'not' not_test | comparison -comparison: expr (comp_op expr)* -# <> isn't actually a valid comparison operator in Python. It's here for the -# sake of a __future__ import described in PEP 401 (which really works :-) -comp_op: '<'|'>'|'=='|'>='|'<='|'<>'|'!='|'in'|'not' 'in'|'is'|'is' 'not' -star_expr: '*' expr -expr: xor_expr ('|' xor_expr)* -xor_expr: and_expr ('^' and_expr)* -and_expr: shift_expr ('&' shift_expr)* -shift_expr: arith_expr (('<<'|'>>') arith_expr)* -arith_expr: term (('+'|'-') term)* -term: factor (('*'|'@'|'/'|'%'|'//') factor)* -factor: ('+'|'-'|'~') factor | power -power: atom_expr ['**' factor] -atom_expr: ['await'] atom trailer* -atom: ('(' [yield_expr|testlist_comp] ')' | - '[' [testlist_comp] ']' | - '{' [dictorsetmaker] '}' | - NAME | NUMBER | STRING+ | '...' | 'None' | 'True' | 'False') -testlist_comp: (test|star_expr) ( comp_for | (',' (test|star_expr))* [','] ) -trailer: '(' [arglist] ')' | '[' subscriptlist ']' | '.' NAME -subscriptlist: subscript (',' subscript)* [','] -subscript: test | [test] ':' [test] [sliceop] -sliceop: ':' [test] -exprlist: (expr|star_expr) (',' (expr|star_expr))* [','] -testlist: test (',' test)* [','] -dictorsetmaker: ( ((test ':' test | '**' expr) - (comp_for | (',' (test ':' test | '**' expr))* [','])) | - ((test | star_expr) - (comp_for | (',' (test | star_expr))* [','])) ) - -classdef: 'class' NAME ['(' [arglist] ')'] ':' suite - -arglist: argument (',' argument)* [','] - -# The reason that keywords are test nodes instead of NAME is that using NAME -# results in an ambiguity. ast.c makes sure it's a NAME. -# "test '=' test" is really "keyword '=' test", but we have no such token. -# These need to be in a single rule to avoid grammar that is ambiguous -# to our LL(1) parser. Even though 'test' includes '*expr' in star_expr, -# we explicitly match '*' here, too, to give it proper precedence. -# Illegal combinations and orderings are blocked in ast.c: -# multiple (test comp_for) arguments are blocked; keyword unpackings -# that precede iterable unpackings are blocked; etc. -argument: ( test [comp_for] | - test '=' test | - '**' test | - '*' test ) - -comp_iter: comp_for | comp_if -comp_for: ['async'] 'for' exprlist 'in' or_test [comp_iter] -comp_if: 'if' test_nocond [comp_iter] - -# not used in grammar, but may appear in "node" passed from Parser to Compiler -encoding_decl: NAME - -yield_expr: 'yield' [yield_arg] -yield_arg: 'from' test | testlist diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/parser.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/parser.py deleted file mode 100644 index 1897f53..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/parser.py +++ /dev/null @@ -1,261 +0,0 @@ -from parso.python import tree -from parso.python.token import (DEDENT, INDENT, ENDMARKER, NEWLINE, NUMBER, - STRING, tok_name, NAME) -from parso.parser import BaseParser -from parso.pgen2.parse import token_to_ilabel - - -class Parser(BaseParser): - """ - This class is used to parse a Python file, it then divides them into a - class structure of different scopes. - - :param pgen_grammar: The grammar object of pgen2. Loaded by load_grammar. - """ - - node_map = { - 'expr_stmt': tree.ExprStmt, - 'classdef': tree.Class, - 'funcdef': tree.Function, - 'file_input': tree.Module, - 'import_name': tree.ImportName, - 'import_from': tree.ImportFrom, - 'break_stmt': tree.KeywordStatement, - 'continue_stmt': tree.KeywordStatement, - 'return_stmt': tree.ReturnStmt, - 'raise_stmt': tree.KeywordStatement, - 'yield_expr': tree.YieldExpr, - 'del_stmt': tree.KeywordStatement, - 'pass_stmt': tree.KeywordStatement, - 'global_stmt': tree.GlobalStmt, - 'nonlocal_stmt': tree.KeywordStatement, - 'print_stmt': tree.KeywordStatement, - 'assert_stmt': tree.AssertStmt, - 'if_stmt': tree.IfStmt, - 'with_stmt': tree.WithStmt, - 'for_stmt': tree.ForStmt, - 'while_stmt': tree.WhileStmt, - 'try_stmt': tree.TryStmt, - 'comp_for': tree.CompFor, - # Not sure if this is the best idea, but IMO it's the easiest way to - # avoid extreme amounts of work around the subtle difference of 2/3 - # grammar in list comoprehensions. - 'list_for': tree.CompFor, - # Same here. This just exists in Python 2.6. - 'gen_for': tree.CompFor, - 'decorator': tree.Decorator, - 'lambdef': tree.Lambda, - 'old_lambdef': tree.Lambda, - 'lambdef_nocond': tree.Lambda, - } - default_node = tree.PythonNode - - def __init__(self, pgen_grammar, error_recovery=True, start_symbol='file_input'): - super(Parser, self).__init__(pgen_grammar, start_symbol, error_recovery=error_recovery) - - self.syntax_errors = [] - self._omit_dedent_list = [] - self._indent_counter = 0 - - # TODO do print absolute import detection here. - # try: - # del python_grammar_no_print_statement.keywords["print"] - # except KeyError: - # pass # Doesn't exist in the Python 3 grammar. - - # if self.options["print_function"]: - # python_grammar = pygram.python_grammar_no_print_statement - # else: - - def parse(self, tokens): - if self._error_recovery: - if self._start_symbol != 'file_input': - raise NotImplementedError - - tokens = self._recovery_tokenize(tokens) - - node = super(Parser, self).parse(tokens) - - if self._start_symbol == 'file_input' != node.type: - # If there's only one statement, we get back a non-module. That's - # not what we want, we want a module, so we add it here: - node = self.convert_node( - self._pgen_grammar, - self._pgen_grammar.symbol2number['file_input'], - [node] - ) - - return node - - def convert_node(self, pgen_grammar, type, children): - """ - Convert raw node information to a PythonBaseNode instance. - - This is passed to the parser driver which calls it whenever a reduction of a - grammar rule produces a new complete node, so that the tree is build - strictly bottom-up. - """ - # TODO REMOVE symbol, we don't want type here. - symbol = pgen_grammar.number2symbol[type] - try: - return self.node_map[symbol](children) - except KeyError: - if symbol == 'suite': - # We don't want the INDENT/DEDENT in our parser tree. Those - # leaves are just cancer. They are virtual leaves and not real - # ones and therefore have pseudo start/end positions and no - # prefixes. Just ignore them. - children = [children[0]] + children[2:-1] - elif symbol == 'list_if': - # Make transitioning from 2 to 3 easier. - symbol = 'comp_if' - elif symbol == 'listmaker': - # Same as list_if above. - symbol = 'testlist_comp' - return self.default_node(symbol, children) - - def convert_leaf(self, pgen_grammar, type, value, prefix, start_pos): - # print('leaf', repr(value), token.tok_name[type]) - if type == NAME: - if value in pgen_grammar.keywords: - return tree.Keyword(value, start_pos, prefix) - else: - return tree.Name(value, start_pos, prefix) - elif type == STRING: - return tree.String(value, start_pos, prefix) - elif type == NUMBER: - return tree.Number(value, start_pos, prefix) - elif type == NEWLINE: - return tree.Newline(value, start_pos, prefix) - elif type == ENDMARKER: - return tree.EndMarker(value, start_pos, prefix) - else: - return tree.Operator(value, start_pos, prefix) - - def error_recovery(self, pgen_grammar, stack, arcs, typ, value, start_pos, prefix, - add_token_callback): - def get_symbol_and_nodes(stack): - for dfa, state, (type_, nodes) in stack: - symbol = pgen_grammar.number2symbol[type_] - yield symbol, nodes - - tos_nodes = stack.get_tos_nodes() - if tos_nodes: - last_leaf = tos_nodes[-1].get_last_leaf() - else: - last_leaf = None - - if self._start_symbol == 'file_input' and \ - (typ == ENDMARKER or typ == DEDENT and '\n' not in last_leaf.value): - def reduce_stack(states, newstate): - # reduce - state = newstate - while states[state] == [(0, state)]: - self.pgen_parser._pop() - - dfa, state, (type_, nodes) = stack[-1] - states, first = dfa - - - # In Python statements need to end with a newline. But since it's - # possible (and valid in Python ) that there's no newline at the - # end of a file, we have to recover even if the user doesn't want - # error recovery. - #print('x', pprint.pprint(stack)) - ilabel = token_to_ilabel(pgen_grammar, NEWLINE, value) - - dfa, state, (type_, nodes) = stack[-1] - symbol = pgen_grammar.number2symbol[type_] - states, first = dfa - arcs = states[state] - # Look for a state with this label - for i, newstate in arcs: - if ilabel == i: - if symbol == 'simple_stmt': - # This is basically shifting - stack[-1] = (dfa, newstate, (type_, nodes)) - - reduce_stack(states, newstate) - add_token_callback(typ, value, start_pos, prefix) - return - # Check if we're at the right point - #for symbol, nodes in get_symbol_and_nodes(stack): - # self.pgen_parser._pop() - - #break - break - #symbol = pgen_grammar.number2symbol[type_] - - if not self._error_recovery: - return super(Parser, self).error_recovery( - pgen_grammar, stack, arcs, typ, value, start_pos, prefix, - add_token_callback) - - def current_suite(stack): - # For now just discard everything that is not a suite or - # file_input, if we detect an error. - for index, (symbol, nodes) in reversed(list(enumerate(get_symbol_and_nodes(stack)))): - # `suite` can sometimes be only simple_stmt, not stmt. - if symbol == 'file_input': - break - elif symbol == 'suite' and len(nodes) > 1: - # suites without an indent in them get discarded. - break - return index, symbol, nodes - - index, symbol, nodes = current_suite(stack) - - # print('err', token.tok_name[typ], repr(value), start_pos, len(stack), index) - if self._stack_removal(pgen_grammar, stack, arcs, index + 1, value, start_pos): - add_token_callback(typ, value, start_pos, prefix) - else: - if typ == INDENT: - # For every deleted INDENT we have to delete a DEDENT as well. - # Otherwise the parser will get into trouble and DEDENT too early. - self._omit_dedent_list.append(self._indent_counter) - - error_leaf = tree.PythonErrorLeaf(tok_name[typ].lower(), value, start_pos, prefix) - stack[-1][2][1].append(error_leaf) - - if symbol == 'suite': - dfa, state, node = stack[-1] - states, first = dfa - arcs = states[state] - intended_label = pgen_grammar.symbol2label['stmt'] - # Introduce a proper state transition. We're basically allowing - # there to be no valid statements inside a suite. - if [x[0] for x in arcs] == [intended_label]: - new_state = arcs[0][1] - stack[-1] = dfa, new_state, node - - def _stack_removal(self, pgen_grammar, stack, arcs, start_index, value, start_pos): - failed_stack = False - found = False - all_nodes = [] - for dfa, state, (type_, nodes) in stack[start_index:]: - if nodes: - found = True - if found: - failed_stack = True - all_nodes += nodes - if failed_stack: - stack[start_index - 1][2][1].append(tree.PythonErrorNode(all_nodes)) - - stack[start_index:] = [] - return failed_stack - - def _recovery_tokenize(self, tokens): - for typ, value, start_pos, prefix in tokens: - # print(tok_name[typ], repr(value), start_pos, repr(prefix)) - if typ == DEDENT: - # We need to count indents, because if we just omit any DEDENT, - # we might omit them in the wrong place. - o = self._omit_dedent_list - if o and o[-1] == self._indent_counter: - o.pop() - continue - - self._indent_counter -= 1 - elif typ == INDENT: - self._indent_counter += 1 - yield typ, value, start_pos, prefix diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/pep8.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/pep8.py deleted file mode 100644 index 59fe452..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/pep8.py +++ /dev/null @@ -1,727 +0,0 @@ -import re -from contextlib import contextmanager - -from parso.python.errors import ErrorFinder, ErrorFinderConfig -from parso.normalizer import Rule -from parso.python.tree import search_ancestor, Flow, Scope - - -_IMPORT_TYPES = ('import_name', 'import_from') -_SUITE_INTRODUCERS = ('classdef', 'funcdef', 'if_stmt', 'while_stmt', - 'for_stmt', 'try_stmt', 'with_stmt') -_NON_STAR_TYPES = ('term', 'import_from', 'power') -_OPENING_BRACKETS = '(', '[', '{' -_CLOSING_BRACKETS = ')', ']', '}' -_FACTOR = '+', '-', '~' -_ALLOW_SPACE = '*', '+', '-', '**', '/', '//', '@' -_BITWISE_OPERATOR = '<<', '>>', '|', '&', '^' -_NEEDS_SPACE = ('=', '%', '->', - '<', '>', '==', '>=', '<=', '<>', '!=', - '+=', '-=', '*=', '@=', '/=', '%=', '&=', '|=', '^=', '<<=', - '>>=', '**=', '//=') -_NEEDS_SPACE += _BITWISE_OPERATOR -_IMPLICIT_INDENTATION_TYPES = ('dictorsetmaker', 'argument') -_POSSIBLE_SLICE_PARENTS = ('subscript', 'subscriptlist', 'sliceop') - - -class IndentationTypes(object): - VERTICAL_BRACKET = object() - HANGING_BRACKET = object() - BACKSLASH = object() - SUITE = object() - IMPLICIT = object() - - -class IndentationNode(object): - type = IndentationTypes.SUITE - - def __init__(self, config, indentation, parent=None): - self.bracket_indentation = self.indentation = indentation - self.parent = parent - - def __repr__(self): - return '<%s>' % self.__class__.__name__ - - def get_latest_suite_node(self): - n = self - while n is not None: - if n.type == IndentationTypes.SUITE: - return n - - n = n.parent - - -class BracketNode(IndentationNode): - def __init__(self, config, leaf, parent, in_suite_introducer=False): - self.leaf = leaf - - # Figure out here what the indentation is. For chained brackets - # we can basically use the previous indentation. - previous_leaf = leaf - n = parent - if n.type == IndentationTypes.IMPLICIT: - n = n.parent - while True: - if hasattr(n, 'leaf') and previous_leaf.line != n.leaf.line: - break - - previous_leaf = previous_leaf.get_previous_leaf() - if not isinstance(n, BracketNode) or previous_leaf != n.leaf: - break - n = n.parent - parent_indentation = n.indentation - - - next_leaf = leaf.get_next_leaf() - if '\n' in next_leaf.prefix: - # This implies code like: - # foobarbaz( - # a, - # b, - # ) - self.bracket_indentation = parent_indentation \ - + config.closing_bracket_hanging_indentation - self.indentation = parent_indentation + config.indentation - self.type = IndentationTypes.HANGING_BRACKET - else: - # Implies code like: - # foobarbaz( - # a, - # b, - # ) - expected_end_indent = leaf.end_pos[1] - if '\t' in config.indentation: - self.indentation = None - else: - self.indentation = ' ' * expected_end_indent - self.bracket_indentation = self.indentation - self.type = IndentationTypes.VERTICAL_BRACKET - - if in_suite_introducer and parent.type == IndentationTypes.SUITE \ - and self.indentation == parent_indentation + config.indentation: - self.indentation += config.indentation - # The closing bracket should have the same indentation. - self.bracket_indentation = self.indentation - self.parent = parent - - -class ImplicitNode(BracketNode): - """ - Implicit indentation after keyword arguments, default arguments, - annotations and dict values. - """ - def __init__(self, config, leaf, parent): - super(ImplicitNode, self).__init__(config, leaf, parent) - self.type = IndentationTypes.IMPLICIT - - next_leaf = leaf.get_next_leaf() - if leaf == ':' and '\n' not in next_leaf.prefix: - self.indentation += ' ' - - -class BackslashNode(IndentationNode): - type = IndentationTypes.BACKSLASH - - def __init__(self, config, parent_indentation, containing_leaf, spacing, parent=None): - expr_stmt = search_ancestor(containing_leaf, 'expr_stmt') - if expr_stmt is not None: - equals = expr_stmt.children[-2] - - if '\t' in config.indentation: - # TODO unite with the code of BracketNode - self.indentation = None - else: - # If the backslash follows the equals, use normal indentation - # otherwise it should align with the equals. - if equals.end_pos == spacing.start_pos: - self.indentation = parent_indentation + config.indentation - else: - # +1 because there is a space. - self.indentation = ' ' * (equals.end_pos[1] + 1) - else: - self.indentation = parent_indentation + config.indentation - self.bracket_indentation = self.indentation - self.parent = parent - - -def _is_magic_name(name): - return name.value.startswith('__') and name.value.endswith('__') - - -class PEP8Normalizer(ErrorFinder): - def __init__(self, *args, **kwargs): - super(PEP8Normalizer, self).__init__(*args, **kwargs) - self._previous_part = None - self._previous_leaf = None - self._on_newline = True - self._newline_count = 0 - self._wanted_newline_count = None - self._max_new_lines_in_prefix = 0 - self._new_statement = True - self._implicit_indentation_possible = False - # The top of stack of the indentation nodes. - self._indentation_tos = self._last_indentation_tos = \ - IndentationNode(self._config, indentation='') - self._in_suite_introducer = False - - if ' ' in self._config.indentation: - self._indentation_type = 'spaces' - self._wrong_indentation_char = '\t' - else: - self._indentation_type = 'tabs' - self._wrong_indentation_char = ' ' - - @contextmanager - def visit_node(self, node): - with super(PEP8Normalizer, self).visit_node(node): - with self._visit_node(node): - yield - - @contextmanager - def _visit_node(self, node): - typ = node.type - - if typ in 'import_name': - names = node.get_defined_names() - if len(names) > 1: - for name in names[:1]: - self.add_issue(name, 401, 'Multiple imports on one line') - elif typ == 'lambdef': - expr_stmt = node.parent - # Check if it's simply defining a single name, not something like - # foo.bar or x[1], where using a lambda could make more sense. - if expr_stmt.type == 'expr_stmt' and any(n.type == 'name' for n in expr_stmt.children[:-2:2]): - self.add_issue(node, 731, 'Do not assign a lambda expression, use a def') - elif typ == 'try_stmt': - for child in node.children: - # Here we can simply check if it's an except, because otherwise - # it would be an except_clause. - if child.type == 'keyword' and child.value == 'except': - self.add_issue(child, 722, 'Do not use bare except, specify exception instead') - elif typ == 'comparison': - for child in node.children: - if child.type not in ('atom_expr', 'power'): - continue - if len(child.children) > 2: - continue - trailer = child.children[1] - atom = child.children[0] - if trailer.type == 'trailer' and atom.type == 'name' \ - and atom.value == 'type': - self.add_issue(node, 721, "Do not compare types, use 'isinstance()") - break - elif typ == 'file_input': - endmarker = node.children[-1] - prev = endmarker.get_previous_leaf() - prefix = endmarker.prefix - if (not prefix.endswith('\n') and ( - prefix or prev is None or prev.value != '\n')): - self.add_issue(endmarker, 292, "No newline at end of file") - - if typ in _IMPORT_TYPES: - simple_stmt = node.parent - module = simple_stmt.parent - #if module.type == 'simple_stmt': - if module.type == 'file_input': - index = module.children.index(simple_stmt) - for child in module.children[:index]: - children = [child] - if child.type == 'simple_stmt': - # Remove the newline. - children = child.children[:-1] - - found_docstring = False - for c in children: - if c.type == 'string' and not found_docstring: - continue - found_docstring = True - - if c.type == 'expr_stmt' and \ - all(_is_magic_name(n) for n in c.get_defined_names()): - continue - - if c.type in _IMPORT_TYPES or isinstance(c, Flow): - continue - - self.add_issue(node, 402, 'Module level import not at top of file') - break - else: - continue - break - - implicit_indentation_possible = typ in _IMPLICIT_INDENTATION_TYPES - in_introducer = typ in _SUITE_INTRODUCERS - if in_introducer: - self._in_suite_introducer = True - elif typ == 'suite': - if self._indentation_tos.type == IndentationTypes.BACKSLASH: - self._indentation_tos = self._indentation_tos.parent - - self._indentation_tos = IndentationNode( - self._config, - self._indentation_tos.indentation + self._config.indentation, - parent=self._indentation_tos - ) - elif implicit_indentation_possible: - self._implicit_indentation_possible = True - yield - if typ == 'suite': - assert self._indentation_tos.type == IndentationTypes.SUITE - self._indentation_tos = self._indentation_tos.parent - # If we dedent, no lines are needed anymore. - self._wanted_newline_count = None - elif implicit_indentation_possible: - self._implicit_indentation_possible = False - if self._indentation_tos.type == IndentationTypes.IMPLICIT: - self._indentation_tos = self._indentation_tos.parent - elif in_introducer: - self._in_suite_introducer = False - if typ in ('classdef', 'funcdef'): - self._wanted_newline_count = self._get_wanted_blank_lines_count() - - def _check_tabs_spaces(self, spacing): - if self._wrong_indentation_char in spacing.value: - self.add_issue(spacing, 101, 'Indentation contains ' + self._indentation_type) - return True - return False - - def _get_wanted_blank_lines_count(self): - suite_node = self._indentation_tos.get_latest_suite_node() - return int(suite_node.parent is None) + 1 - - def _reset_newlines(self, spacing, leaf, is_comment=False): - self._max_new_lines_in_prefix = \ - max(self._max_new_lines_in_prefix, self._newline_count) - - wanted = self._wanted_newline_count - if wanted is not None: - # Need to substract one - blank_lines = self._newline_count - 1 - if wanted > blank_lines and leaf.type != 'endmarker': - # In case of a comment we don't need to add the issue, yet. - if not is_comment: - # TODO end_pos wrong. - code = 302 if wanted == 2 else 301 - message = "expected %s blank line, found %s" \ - % (wanted, blank_lines) - self.add_issue(spacing, code, message) - self._wanted_newline_count = None - else: - self._wanted_newline_count = None - - if not is_comment: - wanted = self._get_wanted_blank_lines_count() - actual = self._max_new_lines_in_prefix - 1 - - val = leaf.value - needs_lines = ( - val == '@' and leaf.parent.type == 'decorator' - or ( - val == 'class' - or val == 'async' and leaf.get_next_leaf() == 'def' - or val == 'def' and self._previous_leaf != 'async' - ) and leaf.parent.parent.type != 'decorated' - ) - if needs_lines and actual < wanted: - func_or_cls = leaf.parent - suite = func_or_cls.parent - if suite.type == 'decorated': - suite = suite.parent - - # The first leaf of a file or a suite should not need blank - # lines. - if suite.children[int(suite.type == 'suite')] != func_or_cls: - code = 302 if wanted == 2 else 301 - message = "expected %s blank line, found %s" \ - % (wanted, actual) - self.add_issue(spacing, code, message) - - self._max_new_lines_in_prefix = 0 - - self._newline_count = 0 - - def visit_leaf(self, leaf): - super(PEP8Normalizer, self).visit_leaf(leaf) - for part in leaf._split_prefix(): - if part.type == 'spacing': - # This part is used for the part call after for. - break - self._visit_part(part, part.create_spacing_part(), leaf) - - self._analyse_non_prefix(leaf) - self._visit_part(leaf, part, leaf) - - # Cleanup - self._last_indentation_tos = self._indentation_tos - - self._new_statement = leaf.type == 'newline' - - # TODO does this work? with brackets and stuff? - if leaf.type == 'newline' and \ - self._indentation_tos.type == IndentationTypes.BACKSLASH: - self._indentation_tos = self._indentation_tos.parent - - if leaf.value == ':' and leaf.parent.type in _SUITE_INTRODUCERS: - self._in_suite_introducer = False - elif leaf.value == 'elif': - self._in_suite_introducer = True - - if not self._new_statement: - self._reset_newlines(part, leaf) - self._max_blank_lines = 0 - - self._previous_leaf = leaf - - return leaf.value - - def _visit_part(self, part, spacing, leaf): - value = part.value - type_ = part.type - if type_ == 'error_leaf': - return - - if value == ',' and part.parent.type == 'dictorsetmaker': - self._indentation_tos = self._indentation_tos.parent - - node = self._indentation_tos - - if type_ == 'comment': - if value.startswith('##'): - # Whole blocks of # should not raise an error. - if value.lstrip('#'): - self.add_issue(part, 266, "Too many leading '#' for block comment.") - elif self._on_newline: - if not re.match('#:? ', value) and not value == '#' \ - and not (value.startswith('#!') and part.start_pos == (1, 0)): - self.add_issue(part, 265, "Block comment should start with '# '") - else: - if not re.match('#:? [^ ]', value): - self.add_issue(part, 262, "Inline comment should start with '# '") - - self._reset_newlines(spacing, leaf, is_comment=True) - elif type_ == 'newline': - if self._newline_count > self._get_wanted_blank_lines_count(): - self.add_issue(part, 303, "Too many blank lines (%s)" % self._newline_count) - elif leaf in ('def', 'class') \ - and leaf.parent.parent.type == 'decorated': - self.add_issue(part, 304, "Blank lines found after function decorator") - - - self._newline_count += 1 - - if type_ == 'backslash': - # TODO is this enough checking? What about ==? - if node.type != IndentationTypes.BACKSLASH: - if node.type != IndentationTypes.SUITE: - self.add_issue(part, 502, 'The backslash is redundant between brackets') - else: - indentation = node.indentation - if self._in_suite_introducer and node.type == IndentationTypes.SUITE: - indentation += self._config.indentation - - self._indentation_tos = BackslashNode( - self._config, - indentation, - part, - spacing, - parent=self._indentation_tos - ) - elif self._on_newline: - indentation = spacing.value - if node.type == IndentationTypes.BACKSLASH \ - and self._previous_part.type == 'newline': - self._indentation_tos = self._indentation_tos.parent - - if not self._check_tabs_spaces(spacing): - should_be_indentation = node.indentation - if type_ == 'comment': - # Comments can be dedented. So we have to care for that. - n = self._last_indentation_tos - while True: - if len(indentation) > len(n.indentation): - break - - should_be_indentation = n.indentation - - self._last_indentation_tos = n - if n == node: - break - n = n.parent - - if self._new_statement: - if type_ == 'newline': - if indentation: - self.add_issue(spacing, 291, 'Trailing whitespace') - elif indentation != should_be_indentation: - s = '%s %s' % (len(self._config.indentation), self._indentation_type) - self.add_issue(part, 111, 'Indentation is not a multiple of ' + s) - else: - if value in '])}': - should_be_indentation = node.bracket_indentation - else: - should_be_indentation = node.indentation - if self._in_suite_introducer and indentation == \ - node.get_latest_suite_node().indentation \ - + self._config.indentation: - self.add_issue(part, 129, "Line with same indent as next logical block") - elif indentation != should_be_indentation: - if not self._check_tabs_spaces(spacing) and part.value != '\n': - if value in '])}': - if node.type == IndentationTypes.VERTICAL_BRACKET: - self.add_issue(part, 124, "Closing bracket does not match visual indentation") - else: - self.add_issue(part, 123, "Losing bracket does not match indentation of opening bracket's line") - else: - if len(indentation) < len(should_be_indentation): - if node.type == IndentationTypes.VERTICAL_BRACKET: - self.add_issue(part, 128, 'Continuation line under-indented for visual indent') - elif node.type == IndentationTypes.BACKSLASH: - self.add_issue(part, 122, 'Continuation line missing indentation or outdented') - elif node.type == IndentationTypes.IMPLICIT: - self.add_issue(part, 135, 'xxx') - else: - self.add_issue(part, 121, 'Continuation line under-indented for hanging indent') - else: - if node.type == IndentationTypes.VERTICAL_BRACKET: - self.add_issue(part, 127, 'Continuation line over-indented for visual indent') - elif node.type == IndentationTypes.IMPLICIT: - self.add_issue(part, 136, 'xxx') - else: - self.add_issue(part, 126, 'Continuation line over-indented for hanging indent') - else: - self._check_spacing(part, spacing) - - self._check_line_length(part, spacing) - # ------------------------------- - # Finalizing. Updating the state. - # ------------------------------- - if value and value in '()[]{}' and type_ != 'error_leaf' \ - and part.parent.type != 'error_node': - if value in _OPENING_BRACKETS: - self._indentation_tos = BracketNode( - self._config, part, - parent=self._indentation_tos, - in_suite_introducer=self._in_suite_introducer - ) - else: - assert node.type != IndentationTypes.IMPLICIT - self._indentation_tos = self._indentation_tos.parent - elif value in ('=', ':') and self._implicit_indentation_possible \ - and part.parent.type in _IMPLICIT_INDENTATION_TYPES: - indentation = node.indentation - self._indentation_tos = ImplicitNode( - self._config, part, parent=self._indentation_tos - ) - - self._on_newline = type_ in ('newline', 'backslash', 'bom') - - self._previous_part = part - self._previous_spacing = spacing - - def _check_line_length(self, part, spacing): - if part.type == 'backslash': - last_column = part.start_pos[1] + 1 - else: - last_column = part.end_pos[1] - if last_column > self._config.max_characters \ - and spacing.start_pos[1] <= self._config.max_characters : - # Special case for long URLs in multi-line docstrings or comments, - # but still report the error when the 72 first chars are whitespaces. - report = True - if part.type == 'comment': - splitted = part.value[1:].split() - if len(splitted) == 1 \ - and (part.end_pos[1] - len(splitted[0])) < 72: - report = False - if report: - self.add_issue( - part, - 501, - 'Line too long (%s > %s characters)' % - (last_column, self._config.max_characters), - ) - - def _check_spacing(self, part, spacing): - def add_if_spaces(*args): - if spaces: - return self.add_issue(*args) - - def add_not_spaces(*args): - if not spaces: - return self.add_issue(*args) - - spaces = spacing.value - prev = self._previous_part - if prev is not None and prev.type == 'error_leaf' or part.type == 'error_leaf': - return - - type_ = part.type - if '\t' in spaces: - self.add_issue(spacing, 223, 'Used tab to separate tokens') - elif type_ == 'comment': - if len(spaces) < self._config.spaces_before_comment: - self.add_issue(spacing, 261, 'At least two spaces before inline comment') - elif type_ == 'newline': - add_if_spaces(spacing, 291, 'Trailing whitespace') - elif len(spaces) > 1: - self.add_issue(spacing, 221, 'Multiple spaces used') - else: - if prev in _OPENING_BRACKETS: - message = "Whitespace after '%s'" % part.value - add_if_spaces(spacing, 201, message) - elif part in _CLOSING_BRACKETS: - message = "Whitespace before '%s'" % part.value - add_if_spaces(spacing, 202, message) - elif part in (',', ';') or part == ':' \ - and part.parent.type not in _POSSIBLE_SLICE_PARENTS: - message = "Whitespace before '%s'" % part.value - add_if_spaces(spacing, 203, message) - elif prev == ':' and prev.parent.type in _POSSIBLE_SLICE_PARENTS: - pass # TODO - elif prev in (',', ';', ':'): - add_not_spaces(spacing, 231, "missing whitespace after '%s'") - elif part == ':': # Is a subscript - # TODO - pass - elif part in ('*', '**') and part.parent.type not in _NON_STAR_TYPES \ - or prev in ('*', '**') \ - and prev.parent.type not in _NON_STAR_TYPES: - # TODO - pass - elif prev in _FACTOR and prev.parent.type == 'factor': - pass - elif prev == '@' and prev.parent.type == 'decorator': - pass # TODO should probably raise an error if there's a space here - elif part in _NEEDS_SPACE or prev in _NEEDS_SPACE: - if part == '=' and part.parent.type in ('argument', 'param') \ - or prev == '=' and prev.parent.type in ('argument', 'param'): - if part == '=': - param = part.parent - else: - param = prev.parent - if param.type == 'param' and param.annotation: - add_not_spaces(spacing, 252, 'Expected spaces around annotation equals') - else: - add_if_spaces(spacing, 251, 'Unexpected spaces around keyword / parameter equals') - elif part in _BITWISE_OPERATOR or prev in _BITWISE_OPERATOR: - add_not_spaces(spacing, 227, 'Missing whitespace around bitwise or shift operator') - elif part == '%' or prev == '%': - add_not_spaces(spacing, 228, 'Missing whitespace around modulo operator') - else: - message_225 = 'Missing whitespace between tokens' - add_not_spaces(spacing, 225, message_225) - elif type_ == 'keyword' or prev.type == 'keyword': - add_not_spaces(spacing, 275, 'Missing whitespace around keyword') - else: - prev_spacing = self._previous_spacing - if prev in _ALLOW_SPACE and spaces != prev_spacing.value \ - and '\n' not in self._previous_leaf.prefix: - message = "Whitespace before operator doesn't match with whitespace after" - self.add_issue(spacing, 229, message) - - if spaces and part not in _ALLOW_SPACE and prev not in _ALLOW_SPACE: - message_225 = 'Missing whitespace between tokens' - #print('xy', spacing) - #self.add_issue(spacing, 225, message_225) - # TODO why only brackets? - if part in _OPENING_BRACKETS: - message = "Whitespace before '%s'" % part.value - add_if_spaces(spacing, 211, message) - - def _analyse_non_prefix(self, leaf): - typ = leaf.type - if typ == 'name' and leaf.value in ('l', 'O', 'I'): - if leaf.is_definition(): - message = "Do not define %s named 'l', 'O', or 'I' one line" - if leaf.parent.type == 'class' and leaf.parent.name == leaf: - self.add_issue(leaf, 742, message % 'classes') - elif leaf.parent.type == 'function' and leaf.parent.name == leaf: - self.add_issue(leaf, 743, message % 'function') - else: - self.add_issuadd_issue(741, message % 'variables', leaf) - elif leaf.value == ':': - if isinstance(leaf.parent, (Flow, Scope)) and leaf.parent.type != 'lambdef': - next_leaf = leaf.get_next_leaf() - if next_leaf.type != 'newline': - if leaf.parent.type == 'funcdef': - self.add_issue(next_leaf, 704, 'Multiple statements on one line (def)') - else: - self.add_issue(next_leaf, 701, 'Multiple statements on one line (colon)') - elif leaf.value == ';': - if leaf.get_next_leaf().type in ('newline', 'endmarker'): - self.add_issue(leaf, 703, 'Statement ends with a semicolon') - else: - self.add_issue(leaf, 702, 'Multiple statements on one line (semicolon)') - elif leaf.value in ('==', '!='): - comparison = leaf.parent - index = comparison.children.index(leaf) - left = comparison.children[index - 1] - right = comparison.children[index + 1] - for node in left, right: - if node.type == 'keyword' or node.type == 'name': - if node.value == 'None': - message = "comparison to None should be 'if cond is None:'" - self.add_issue(leaf, 711, message) - break - elif node.value in ('True', 'False'): - message = "comparison to False/True should be 'if cond is True:' or 'if cond:'" - self.add_issue(leaf, 712, message) - break - elif leaf.value in ('in', 'is'): - comparison = leaf.parent - if comparison.type == 'comparison' and comparison.parent.type == 'not_test': - if leaf.value == 'in': - self.add_issue(leaf, 713, "test for membership should be 'not in'") - else: - self.add_issue(leaf, 714, "test for object identity should be 'is not'") - elif typ == 'string': - # Checking multiline strings - for i, line in enumerate(leaf.value.splitlines()[1:]): - indentation = re.match('[ \t]*', line).group(0) - start_pos = leaf.line + i, len(indentation) - # TODO check multiline indentation. - elif typ == 'endmarker': - if self._newline_count >= 2: - self.add_issue(leaf, 391, 'Blank line at end of file') - - def add_issue(self, node, code, message): - if self._previous_leaf is not None: - if search_ancestor(self._previous_leaf, 'error_node') is not None: - return - if self._previous_leaf.type == 'error_leaf': - return - if search_ancestor(node, 'error_node') is not None: - return - if code in (901, 903): - # 901 and 903 are raised by the ErrorFinder. - super(PEP8Normalizer, self).add_issue(node, code, message) - else: - # Skip ErrorFinder here, because it has custom behavior. - super(ErrorFinder, self).add_issue(node, code, message) - - -class PEP8NormalizerConfig(ErrorFinderConfig): - normalizer_class = PEP8Normalizer - """ - Normalizing to PEP8. Not really implemented, yet. - """ - def __init__(self, indentation=' ' * 4, hanging_indentation=None, - max_characters=79, spaces_before_comment=2): - self.indentation = indentation - if hanging_indentation is None: - hanging_indentation = indentation - self.hanging_indentation = hanging_indentation - self.closing_bracket_hanging_indentation = '' - self.break_after_binary = False - self.max_characters = max_characters - self.spaces_before_comment = spaces_before_comment - - -# TODO this is not yet ready. -#@PEP8Normalizer.register_rule(type='endmarker') -class BlankLineAtEnd(Rule): - code = 392 - message = 'Blank line at end of file' - - def is_issue(self, leaf): - return self._newline_count >= 2 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/prefix.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/prefix.py deleted file mode 100644 index b7f1e1b..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/prefix.py +++ /dev/null @@ -1,97 +0,0 @@ -import re -from codecs import BOM_UTF8 - -from parso.python.tokenize import group - -unicode_bom = BOM_UTF8.decode('utf-8') - - -class PrefixPart(object): - def __init__(self, leaf, typ, value, spacing='', start_pos=None): - assert start_pos is not None - self.parent = leaf - self.type = typ - self.value = value - self.spacing = spacing - self.start_pos = start_pos - - @property - def end_pos(self): - if self.value.endswith('\n'): - return self.start_pos[0] + 1, 0 - if self.value == unicode_bom: - # The bom doesn't have a length at the start of a Python file. - return self.start_pos - return self.start_pos[0], self.start_pos[1] + len(self.value) - - def create_spacing_part(self): - column = self.start_pos[1] - len(self.spacing) - return PrefixPart( - self.parent, 'spacing', self.spacing, - start_pos=(self.start_pos[0], column) - ) - - def __repr__(self): - return '%s(%s, %s, %s)' % ( - self.__class__.__name__, - self.type, - repr(self.value), - self.start_pos - ) - - -_comment = r'#[^\n\r\f]*' -_backslash = r'\\\r?\n' -_newline = r'\r?\n' -_form_feed = r'\f' -_only_spacing = '$' -_spacing = r'[ \t]*' -_bom = unicode_bom - -_regex = group( - _comment, _backslash, _newline, _form_feed, _only_spacing, _bom, - capture=True -) -_regex = re.compile(group(_spacing, capture=True) + _regex) - - -_types = { - '#': 'comment', - '\\': 'backslash', - '\f': 'formfeed', - '\n': 'newline', - '\r': 'newline', - unicode_bom: 'bom' -} - - -def split_prefix(leaf, start_pos): - line, column = start_pos - start = 0 - value = spacing = '' - bom = False - while start != len(leaf.prefix): - match =_regex.match(leaf.prefix, start) - spacing = match.group(1) - value = match.group(2) - if not value: - break - type_ = _types[value[0]] - yield PrefixPart( - leaf, type_, value, spacing, - start_pos=(line, column + start - int(bom) + len(spacing)) - ) - if type_ == 'bom': - bom = True - - start = match.end(0) - if value.endswith('\n'): - line += 1 - column = -start - - if value: - spacing = '' - yield PrefixPart( - leaf, 'spacing', spacing, - start_pos=(line, column + start) - ) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/token.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/token.py deleted file mode 100644 index fb590a5..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/token.py +++ /dev/null @@ -1,104 +0,0 @@ -from __future__ import absolute_import -from itertools import count -from token import * - -from parso._compatibility import py_version - - -_counter = count(N_TOKENS) -# Never want to see this thing again. -del N_TOKENS - -COMMENT = next(_counter) -tok_name[COMMENT] = 'COMMENT' - -NL = next(_counter) -tok_name[NL] = 'NL' - -# Sets the attributes that don't exist in these tok_name versions. -if py_version >= 30: - BACKQUOTE = next(_counter) - tok_name[BACKQUOTE] = 'BACKQUOTE' -else: - RARROW = next(_counter) - tok_name[RARROW] = 'RARROW' - ELLIPSIS = next(_counter) - tok_name[ELLIPSIS] = 'ELLIPSIS' - -if py_version < 35: - ATEQUAL = next(_counter) - tok_name[ATEQUAL] = 'ATEQUAL' - -ERROR_DEDENT = next(_counter) -tok_name[ERROR_DEDENT] = 'ERROR_DEDENT' - - -# Map from operator to number (since tokenize doesn't do this) - -opmap_raw = """\ -( LPAR -) RPAR -[ LSQB -] RSQB -: COLON -, COMMA -; SEMI -+ PLUS -- MINUS -* STAR -/ SLASH -| VBAR -& AMPER -< LESS -> GREATER -= EQUAL -. DOT -% PERCENT -` BACKQUOTE -{ LBRACE -} RBRACE -@ AT -== EQEQUAL -!= NOTEQUAL -<> NOTEQUAL -<= LESSEQUAL ->= GREATEREQUAL -~ TILDE -^ CIRCUMFLEX -<< LEFTSHIFT ->> RIGHTSHIFT -** DOUBLESTAR -+= PLUSEQUAL --= MINEQUAL -*= STAREQUAL -/= SLASHEQUAL -%= PERCENTEQUAL -&= AMPEREQUAL -|= VBAREQUAL -@= ATEQUAL -^= CIRCUMFLEXEQUAL -<<= LEFTSHIFTEQUAL ->>= RIGHTSHIFTEQUAL -**= DOUBLESTAREQUAL -// DOUBLESLASH -//= DOUBLESLASHEQUAL --> RARROW -... ELLIPSIS -""" - -opmap = {} -for line in opmap_raw.splitlines(): - op, name = line.split() - opmap[op] = globals()[name] - - -def generate_token_id(string): - """ - Uses a token in the grammar (e.g. `'+'` or `'and'`returns the corresponding - ID for it. The strings are part of the grammar file. - """ - try: - return opmap[string] - except KeyError: - pass - return globals()[string] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/tokenize.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/tokenize.py deleted file mode 100644 index ecd2437..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/tokenize.py +++ /dev/null @@ -1,420 +0,0 @@ -# -*- coding: utf-8 -*- -""" -This tokenizer has been copied from the ``tokenize.py`` standard library -tokenizer. The reason was simple: The standard library tokenizer fails -if the indentation is not right. To make it possible to do error recovery the - tokenizer needed to be rewritten. - -Basically this is a stripped down version of the standard library module, so -you can read the documentation there. Additionally we included some speed and -memory optimizations here. -""" -from __future__ import absolute_import - -import sys -import string -import re -from collections import namedtuple -import itertools as _itertools -from codecs import BOM_UTF8 - -from parso.python.token import (tok_name, ENDMARKER, STRING, NUMBER, opmap, - NAME, ERRORTOKEN, NEWLINE, INDENT, DEDENT, - ERROR_DEDENT) -from parso._compatibility import py_version -from parso.utils import split_lines - - -TokenCollection = namedtuple( - 'TokenCollection', - 'pseudo_token single_quoted triple_quoted endpats always_break_tokens', -) - -BOM_UTF8_STRING = BOM_UTF8.decode('utf-8') - -_token_collection_cache = {} - -if py_version >= 30: - # Python 3 has str.isidentifier() to check if a char is a valid identifier - is_identifier = str.isidentifier -else: - namechars = string.ascii_letters + '_' - is_identifier = lambda s: s in namechars - - -def group(*choices, **kwargs): - capture = kwargs.pop('capture', False) # Python 2, arrghhhhh :( - assert not kwargs - - start = '(' - if not capture: - start += '?:' - return start + '|'.join(choices) + ')' - - -def any(*choices): - return group(*choices) + '*' - - -def maybe(*choices): - return group(*choices) + '?' - - -# Return the empty string, plus all of the valid string prefixes. -def _all_string_prefixes(version_info): - def different_case_versions(prefix): - for s in _itertools.product(*[(c, c.upper()) for c in prefix]): - yield ''.join(s) - # The valid string prefixes. Only contain the lower case versions, - # and don't contain any permuations (include 'fr', but not - # 'rf'). The various permutations will be generated. - _valid_string_prefixes = ['b', 'r', 'u'] - if version_info >= (3, 0): - _valid_string_prefixes.append('br') - - if version_info >= (3, 6): - _valid_string_prefixes += ['f', 'fr'] - - # if we add binary f-strings, add: ['fb', 'fbr'] - result = set(['']) - for prefix in _valid_string_prefixes: - for t in _itertools.permutations(prefix): - # create a list with upper and lower versions of each - # character - result.update(different_case_versions(t)) - if version_info <= (2, 7): - # In Python 2 the order cannot just be random. - result.update(different_case_versions('ur')) - result.update(different_case_versions('br')) - return result - - -def _compile(expr): - return re.compile(expr, re.UNICODE) - - -def _get_token_collection(version_info): - try: - return _token_collection_cache[tuple(version_info)] - except KeyError: - _token_collection_cache[tuple(version_info)] = result = \ - _create_token_collection(version_info) - return result - - -def _create_token_collection(version_info): - # Note: we use unicode matching for names ("\w") but ascii matching for - # number literals. - Whitespace = r'[ \f\t]*' - Comment = r'#[^\r\n]*' - Name = r'\w+' - - if version_info >= (3, 6): - Hexnumber = r'0[xX](?:_?[0-9a-fA-F])+' - Binnumber = r'0[bB](?:_?[01])+' - Octnumber = r'0[oO](?:_?[0-7])+' - Decnumber = r'(?:0(?:_?0)*|[1-9](?:_?[0-9])*)' - Intnumber = group(Hexnumber, Binnumber, Octnumber, Decnumber) - Exponent = r'[eE][-+]?[0-9](?:_?[0-9])*' - Pointfloat = group(r'[0-9](?:_?[0-9])*\.(?:[0-9](?:_?[0-9])*)?', - r'\.[0-9](?:_?[0-9])*') + maybe(Exponent) - Expfloat = r'[0-9](?:_?[0-9])*' + Exponent - Floatnumber = group(Pointfloat, Expfloat) - Imagnumber = group(r'[0-9](?:_?[0-9])*[jJ]', Floatnumber + r'[jJ]') - else: - Hexnumber = r'0[xX][0-9a-fA-F]+' - Binnumber = r'0[bB][01]+' - if version_info >= (3, 0): - Octnumber = r'0[oO][0-7]+' - else: - Octnumber = '0[oO]?[0-7]+' - Decnumber = r'(?:0+|[1-9][0-9]*)' - Intnumber = group(Hexnumber, Binnumber, Octnumber, Decnumber) - Exponent = r'[eE][-+]?[0-9]+' - Pointfloat = group(r'[0-9]+\.[0-9]*', r'\.[0-9]+') + maybe(Exponent) - Expfloat = r'[0-9]+' + Exponent - Floatnumber = group(Pointfloat, Expfloat) - Imagnumber = group(r'[0-9]+[jJ]', Floatnumber + r'[jJ]') - Number = group(Imagnumber, Floatnumber, Intnumber) - - # Note that since _all_string_prefixes includes the empty string, - # StringPrefix can be the empty string (making it optional). - possible_prefixes = _all_string_prefixes(version_info) - StringPrefix = group(*possible_prefixes) - - # Tail end of ' string. - Single = r"[^'\\]*(?:\\.[^'\\]*)*'" - # Tail end of " string. - Double = r'[^"\\]*(?:\\.[^"\\]*)*"' - # Tail end of ''' string. - Single3 = r"[^'\\]*(?:(?:\\.|'(?!''))[^'\\]*)*'''" - # Tail end of """ string. - Double3 = r'[^"\\]*(?:(?:\\.|"(?!""))[^"\\]*)*"""' - Triple = group(StringPrefix + "'''", StringPrefix + '"""') - - # Because of leftmost-then-longest match semantics, be sure to put the - # longest operators first (e.g., if = came before ==, == would get - # recognized as two instances of =). - Operator = group(r"\*\*=?", r">>=?", r"<<=?", r"!=", - r"//=?", r"->", - r"[+\-*/%&@`|^=<>]=?", - r"~") - - Bracket = '[][(){}]' - - special_args = [r'\r?\n', r'[:;.,@]'] - if version_info >= (3, 0): - special_args.insert(0, r'\.\.\.') - Special = group(*special_args) - - Funny = group(Operator, Bracket, Special) - - # First (or only) line of ' or " string. - ContStr = group(StringPrefix + r"'[^\n'\\]*(?:\\.[^\n'\\]*)*" + - group("'", r'\\\r?\n'), - StringPrefix + r'"[^\n"\\]*(?:\\.[^\n"\\]*)*' + - group('"', r'\\\r?\n')) - PseudoExtras = group(r'\\\r?\n|\Z', Comment, Triple) - PseudoToken = group(Whitespace, capture=True) + \ - group(PseudoExtras, Number, Funny, ContStr, Name, capture=True) - - # For a given string prefix plus quotes, endpats maps it to a regex - # to match the remainder of that string. _prefix can be empty, for - # a normal single or triple quoted string (with no prefix). - endpats = {} - for _prefix in possible_prefixes: - endpats[_prefix + "'"] = _compile(Single) - endpats[_prefix + '"'] = _compile(Double) - endpats[_prefix + "'''"] = _compile(Single3) - endpats[_prefix + '"""'] = _compile(Double3) - - # A set of all of the single and triple quoted string prefixes, - # including the opening quotes. - single_quoted = set() - triple_quoted = set() - for t in possible_prefixes: - for p in (t + '"', t + "'"): - single_quoted.add(p) - for p in (t + '"""', t + "'''"): - triple_quoted.add(p) - - ALWAYS_BREAK_TOKENS = (';', 'import', 'class', 'def', 'try', 'except', - 'finally', 'while', 'with', 'return') - pseudo_token_compiled = _compile(PseudoToken) - return TokenCollection( - pseudo_token_compiled, single_quoted, triple_quoted, endpats, - ALWAYS_BREAK_TOKENS - ) - - -class Token(namedtuple('Token', ['type', 'string', 'start_pos', 'prefix'])): - @property - def end_pos(self): - lines = split_lines(self.string) - if len(lines) > 1: - return self.start_pos[0] + len(lines) - 1, 0 - else: - return self.start_pos[0], self.start_pos[1] + len(self.string) - - -class PythonToken(Token): - def _get_type_name(self, exact=True): - return tok_name[self.type] - - def __repr__(self): - return ('TokenInfo(type=%s, string=%r, start=%r, prefix=%r)' % - self._replace(type=self._get_type_name())) - - -def tokenize(code, version_info, start_pos=(1, 0)): - """Generate tokens from a the source code (string).""" - lines = split_lines(code, keepends=True) - return tokenize_lines(lines, version_info, start_pos=start_pos) - - -def tokenize_lines(lines, version_info, start_pos=(1, 0)): - """ - A heavily modified Python standard library tokenizer. - - Additionally to the default information, yields also the prefix of each - token. This idea comes from lib2to3. The prefix contains all information - that is irrelevant for the parser like newlines in parentheses or comments. - """ - pseudo_token, single_quoted, triple_quoted, endpats, always_break_tokens, = \ - _get_token_collection(version_info) - paren_level = 0 # count parentheses - indents = [0] - max = 0 - numchars = '0123456789' - contstr = '' - contline = None - # We start with a newline. This makes indent at the first position - # possible. It's not valid Python, but still better than an INDENT in the - # second line (and not in the first). This makes quite a few things in - # Jedi's fast parser possible. - new_line = True - prefix = '' # Should never be required, but here for safety - additional_prefix = '' - first = True - lnum = start_pos[0] - 1 - for line in lines: # loop over lines in stream - lnum += 1 - pos = 0 - max = len(line) - if first: - if line.startswith(BOM_UTF8_STRING): - additional_prefix = BOM_UTF8_STRING - line = line[1:] - max = len(line) - - # Fake that the part before was already parsed. - line = '^' * start_pos[1] + line - pos = start_pos[1] - max += start_pos[1] - - first = False - - if contstr: # continued string - endmatch = endprog.match(line) - if endmatch: - pos = endmatch.end(0) - yield PythonToken(STRING, contstr + line[:pos], contstr_start, prefix) - contstr = '' - contline = None - else: - contstr = contstr + line - contline = contline + line - continue - - while pos < max: - pseudomatch = pseudo_token.match(line, pos) - if not pseudomatch: # scan for tokens - txt = line[pos:] - if txt.endswith('\n'): - new_line = True - yield PythonToken(ERRORTOKEN, txt, (lnum, pos), additional_prefix) - additional_prefix = '' - break - - prefix = additional_prefix + pseudomatch.group(1) - additional_prefix = '' - start, pos = pseudomatch.span(2) - spos = (lnum, start) - token = pseudomatch.group(2) - if token == '': - assert prefix - additional_prefix = prefix - # This means that we have a line with whitespace/comments at - # the end, which just results in an endmarker. - break - initial = token[0] - - if new_line and initial not in '\r\n#': - new_line = False - if paren_level == 0: - i = 0 - while line[i] == '\f': - i += 1 - start -= 1 - if start > indents[-1]: - yield PythonToken(INDENT, '', spos, '') - indents.append(start) - while start < indents[-1]: - if start > indents[-2]: - yield PythonToken(ERROR_DEDENT, '', (lnum, 0), '') - break - yield PythonToken(DEDENT, '', spos, '') - indents.pop() - - if (initial in numchars or # ordinary number - (initial == '.' and token != '.' and token != '...')): - yield PythonToken(NUMBER, token, spos, prefix) - elif initial in '\r\n': - if not new_line and paren_level == 0: - yield PythonToken(NEWLINE, token, spos, prefix) - else: - additional_prefix = prefix + token - new_line = True - elif initial == '#': # Comments - assert not token.endswith("\n") - additional_prefix = prefix + token - elif token in triple_quoted: - endprog = endpats[token] - endmatch = endprog.match(line, pos) - if endmatch: # all on one line - pos = endmatch.end(0) - token = line[start:pos] - yield PythonToken(STRING, token, spos, prefix) - else: - contstr_start = (lnum, start) # multiple lines - contstr = line[start:] - contline = line - break - elif initial in single_quoted or \ - token[:2] in single_quoted or \ - token[:3] in single_quoted: - if token[-1] == '\n': # continued string - contstr_start = lnum, start - endprog = (endpats.get(initial) or endpats.get(token[1]) - or endpats.get(token[2])) - contstr = line[start:] - contline = line - break - else: # ordinary string - yield PythonToken(STRING, token, spos, prefix) - elif is_identifier(initial): # ordinary name - if token in always_break_tokens: - paren_level = 0 - while True: - indent = indents.pop() - if indent > start: - yield PythonToken(DEDENT, '', spos, '') - else: - indents.append(indent) - break - yield PythonToken(NAME, token, spos, prefix) - elif initial == '\\' and line[start:] in ('\\\n', '\\\r\n'): # continued stmt - additional_prefix += prefix + line[start:] - break - else: - if token in '([{': - paren_level += 1 - elif token in ')]}': - paren_level -= 1 - - try: - # This check is needed in any case to check if it's a valid - # operator or just some random unicode character. - typ = opmap[token] - except KeyError: - typ = ERRORTOKEN - yield PythonToken(typ, token, spos, prefix) - - if contstr: - yield PythonToken(ERRORTOKEN, contstr, contstr_start, prefix) - if contstr.endswith('\n'): - new_line = True - - end_pos = lnum, max - # As the last position we just take the maximally possible position. We - # remove -1 for the last new line. - for indent in indents[1:]: - yield PythonToken(DEDENT, '', end_pos, '') - yield PythonToken(ENDMARKER, '', end_pos, additional_prefix) - - -if __name__ == "__main__": - if len(sys.argv) >= 2: - path = sys.argv[1] - with open(path) as f: - code = f.read() - else: - code = sys.stdin.read() - - from parso.utils import python_bytes_to_unicode, parse_version_string - - if isinstance(code, bytes): - code = python_bytes_to_unicode(code) - - for token in tokenize(code, parse_version_string()): - print(token) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/tree.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/tree.py deleted file mode 100644 index eb97780..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/python/tree.py +++ /dev/null @@ -1,1165 +0,0 @@ -""" -This is the syntax tree for Python syntaxes (2 & 3). The classes represent -syntax elements like functions and imports. - -All of the nodes can be traced back to the `Python grammar file -`_. If you want to know how -a tree is structured, just analyse that file (for each Python version it's a -bit different). - -There's a lot of logic here that makes it easier for Jedi (and other libraries) -to deal with a Python syntax tree. - -By using :py:meth:`parso.tree.NodeOrLeaf.get_code` on a module, you can get -back the 1-to-1 representation of the input given to the parser. This is -important if you want to refactor a parser tree. - ->>> from parso import parse ->>> parser = parse('import os') ->>> module = parser.get_root_node() ->>> module - - -Any subclasses of :class:`Scope`, including :class:`Module` has an attribute -:attr:`iter_imports `: - ->>> list(module.iter_imports()) -[] - -Changes to the Python Grammar ------------------------------ - -A few things have changed when looking at Python grammar files: - -- :class:`Param` does not exist in Python grammar files. It is essentially a - part of a ``parameters`` node. |parso| splits it up to make it easier to - analyse parameters. However this just makes it easier to deal with the syntax - tree, it doesn't actually change the valid syntax. -- A few nodes like `lambdef` and `lambdef_nocond` have been merged in the - syntax tree to make it easier to do deal with them. - -Parser Tree Classes -------------------- -""" - -import re - -from parso._compatibility import utf8_repr, unicode -from parso.tree import Node, BaseNode, Leaf, ErrorNode, ErrorLeaf, \ - search_ancestor -from parso.python.prefix import split_prefix - -_FLOW_CONTAINERS = set(['if_stmt', 'while_stmt', 'for_stmt', 'try_stmt', - 'with_stmt', 'async_stmt', 'suite']) -_RETURN_STMT_CONTAINERS = set(['suite', 'simple_stmt']) | _FLOW_CONTAINERS -_FUNC_CONTAINERS = set(['suite', 'simple_stmt', 'decorated']) | _FLOW_CONTAINERS -_GET_DEFINITION_TYPES = set([ - 'expr_stmt', 'comp_for', 'with_stmt', 'for_stmt', 'import_name', - 'import_from', 'param' -]) -_IMPORTS = set(['import_name', 'import_from']) - - - -class DocstringMixin(object): - __slots__ = () - - def get_doc_node(self): - """ - Returns the string leaf of a docstring. e.g. ``r'''foo'''``. - """ - if self.type == 'file_input': - node = self.children[0] - elif self.type in ('funcdef', 'classdef'): - node = self.children[self.children.index(':') + 1] - if node.type == 'suite': # Normally a suite - node = node.children[1] # -> NEWLINE stmt - else: # ExprStmt - simple_stmt = self.parent - c = simple_stmt.parent.children - index = c.index(simple_stmt) - if not index: - return None - node = c[index - 1] - - if node.type == 'simple_stmt': - node = node.children[0] - if node.type == 'string': - return node - return None - - -class PythonMixin(object): - """ - Some Python specific utitilies. - """ - __slots__ = () - - def get_name_of_position(self, position): - """ - Given a (line, column) tuple, returns a :py:class:`Name` or ``None`` if - there is no name at that position. - """ - for c in self.children: - if isinstance(c, Leaf): - if c.type == 'name' and c.start_pos <= position <= c.end_pos: - return c - else: - result = c.get_name_of_position(position) - if result is not None: - return result - return None - - -class PythonLeaf(PythonMixin, Leaf): - __slots__ = () - - def _split_prefix(self): - return split_prefix(self, self.get_start_pos_of_prefix()) - - def get_start_pos_of_prefix(self): - """ - Basically calls :py:meth:`parso.tree.NodeOrLeaf.get_start_pos_of_prefix`. - """ - # TODO it is really ugly that we have to override it. Maybe change - # indent error leafs somehow? No idea how, though. - previous_leaf = self.get_previous_leaf() - if previous_leaf is not None and previous_leaf.type == 'error_leaf' \ - and previous_leaf.original_type in ('indent', 'error_dedent'): - previous_leaf = previous_leaf.get_previous_leaf() - - if previous_leaf is None: - return self.line - self.prefix.count('\n'), 0 # It's the first leaf. - return previous_leaf.end_pos - - - -class _LeafWithoutNewlines(PythonLeaf): - """ - Simply here to optimize performance. - """ - __slots__ = () - - @property - def end_pos(self): - return self.line, self.column + len(self.value) - - -# Python base classes -class PythonBaseNode(PythonMixin, BaseNode): - __slots__ = () - - -class PythonNode(PythonMixin, Node): - __slots__ = () - - -class PythonErrorNode(PythonMixin, ErrorNode): - __slots__ = () - - -class PythonErrorLeaf(ErrorLeaf, PythonLeaf): - __slots__ = () - - -class EndMarker(_LeafWithoutNewlines): - __slots__ = () - type = 'endmarker' - - -class Newline(PythonLeaf): - """Contains NEWLINE and ENDMARKER tokens.""" - __slots__ = () - type = 'newline' - - @utf8_repr - def __repr__(self): - return "<%s: %s>" % (type(self).__name__, repr(self.value)) - - -class Name(_LeafWithoutNewlines): - """ - A string. Sometimes it is important to know if the string belongs to a name - or not. - """ - type = 'name' - __slots__ = () - - def __repr__(self): - return "<%s: %s@%s,%s>" % (type(self).__name__, self.value, - self.line, self.column) - - def is_definition(self): - """ - Returns True if the name is being defined. - """ - return self.get_definition() is not None - - def get_definition(self, import_name_always=False): - """ - Returns None if there's on definition for a name. - - :param import_name_alway: Specifies if an import name is always a - definition. Normally foo in `from foo import bar` is not a - definition. - """ - node = self.parent - type_ = node.type - if type_ in ('power', 'atom_expr'): - # In `self.x = 3` self is not a definition, but x is. - return None - - if type_ in ('funcdef', 'classdef'): - if self == node.name: - return node - return None - - if type_ == 'except_clause': - # TODO in Python 2 this doesn't work correctly. See grammar file. - # I think we'll just let it be. Python 2 will be gone in a few - # years. - if self.get_previous_sibling() == 'as': - return node.parent # The try_stmt. - return None - - while node is not None: - if node.type == 'suite': - return None - if node.type in _GET_DEFINITION_TYPES: - if self in node.get_defined_names(): - return node - if import_name_always and node.type in _IMPORTS: - return node - return None - node = node.parent - return None - - - -class Literal(PythonLeaf): - __slots__ = () - - -class Number(Literal): - type = 'number' - __slots__ = () - - -class String(Literal): - type = 'string' - __slots__ = () - - @property - def string_prefix(self): - return re.match('\w*(?=[\'"])', self.value).group(0) - - def _get_payload(self): - match = re.search( - r'''('{3}|"{3}|'|")(.*)$''', - self.value, - flags=re.DOTALL - ) - return match.group(2)[:-len(match.group(1))] - - -class _StringComparisonMixin(object): - def __eq__(self, other): - """ - Make comparisons with strings easy. - Improves the readability of the parser. - """ - if isinstance(other, (str, unicode)): - return self.value == other - - return self is other - - def __ne__(self, other): - """Python 2 compatibility.""" - return not self.__eq__(other) - - def __hash__(self): - return hash(self.value) - - -class Operator(_LeafWithoutNewlines, _StringComparisonMixin): - type = 'operator' - __slots__ = () - - -class Keyword(_LeafWithoutNewlines, _StringComparisonMixin): - type = 'keyword' - __slots__ = () - - -class Scope(PythonBaseNode, DocstringMixin): - """ - Super class for the parser tree, which represents the state of a python - text file. - A Scope is either a function, class or lambda. - """ - __slots__ = () - - def __init__(self, children): - super(Scope, self).__init__(children) - - def iter_funcdefs(self): - """ - Returns a generator of `funcdef` nodes. - """ - return self._search_in_scope('funcdef') - - def iter_classdefs(self): - """ - Returns a generator of `classdef` nodes. - """ - return self._search_in_scope('classdef') - - def iter_imports(self): - """ - Returns a generator of `import_name` and `import_from` nodes. - """ - return self._search_in_scope('import_name', 'import_from') - - def _search_in_scope(self, *names): - def scan(children): - for element in children: - if element.type in names: - yield element - if element.type in _FUNC_CONTAINERS: - for e in scan(element.children): - yield e - - return scan(self.children) - - def get_suite(self): - """ - Returns the part that is executed by the function. - """ - return self.children[-1] - - def __repr__(self): - try: - name = self.name.value - except AttributeError: - name = '' - - return "<%s: %s@%s-%s>" % (type(self).__name__, name, - self.start_pos[0], self.end_pos[0]) - - -class Module(Scope): - """ - The top scope, which is always a module. - Depending on the underlying parser this may be a full module or just a part - of a module. - """ - __slots__ = ('_used_names',) - type = 'file_input' - - def __init__(self, children): - super(Module, self).__init__(children) - self._used_names = None - - def _iter_future_import_names(self): - """ - :return: A list of future import names. - :rtype: list of str - """ - # In Python it's not allowed to use future imports after the first - # actual (non-future) statement. However this is not a linter here, - # just return all future imports. If people want to scan for issues - # they should use the API. - for imp in self.iter_imports(): - if imp.type == 'import_from' and imp.level == 0: - for path in imp.get_paths(): - names = [name.value for name in path] - if len(names) == 2 and names[0] == '__future__': - yield names[1] - - def _has_explicit_absolute_import(self): - """ - Checks if imports in this module are explicitly absolute, i.e. there - is a ``__future__`` import. - Currently not public, might be in the future. - :return bool: - """ - for name in self._iter_future_import_names(): - if name == 'absolute_import': - return True - return False - - def get_used_names(self): - """ - Returns all the :class:`Name` leafs that exist in this module. This - includes both definitions and references of names. - """ - if self._used_names is None: - # Don't directly use self._used_names to eliminate a lookup. - dct = {} - - def recurse(node): - try: - children = node.children - except AttributeError: - if node.type == 'name': - arr = dct.setdefault(node.value, []) - arr.append(node) - else: - for child in children: - recurse(child) - - recurse(self) - self._used_names = dct - return self._used_names - - -class Decorator(PythonBaseNode): - type = 'decorator' - __slots__ = () - - -class ClassOrFunc(Scope): - __slots__ = () - - @property - def name(self): - """ - Returns the `Name` leaf that defines the function or class name. - """ - return self.children[1] - - def get_decorators(self): - """ - :rtype: list of :class:`Decorator` - """ - decorated = self.parent - if decorated.type == 'decorated': - if decorated.children[0].type == 'decorators': - return decorated.children[0].children - else: - return decorated.children[:1] - else: - return [] - - -class Class(ClassOrFunc): - """ - Used to store the parsed contents of a python class. - """ - type = 'classdef' - __slots__ = () - - def __init__(self, children): - super(Class, self).__init__(children) - - def get_super_arglist(self): - """ - Returns the `arglist` node that defines the super classes. It returns - None if there are no arguments. - """ - if self.children[2] != '(': # Has no parentheses - return None - else: - if self.children[3] == ')': # Empty parentheses - return None - else: - return self.children[3] - - -def _create_params(parent, argslist_list): - """ - `argslist_list` is a list that can contain an argslist as a first item, but - most not. It's basically the items between the parameter brackets (which is - at most one item). - This function modifies the parser structure. It generates `Param` objects - from the normal ast. Those param objects do not exist in a normal ast, but - make the evaluation of the ast tree so much easier. - You could also say that this function replaces the argslist node with a - list of Param objects. - """ - def check_python2_nested_param(node): - """ - Python 2 allows params to look like ``def x(a, (b, c))``, which is - basically a way of unpacking tuples in params. Python 3 has ditched - this behavior. Jedi currently just ignores those constructs. - """ - return node.type == 'fpdef' and node.children[0] == '(' - - try: - first = argslist_list[0] - except IndexError: - return [] - - if first.type in ('name', 'fpdef'): - if check_python2_nested_param(first): - return [first] - else: - return [Param([first], parent)] - elif first == '*': - return [first] - else: # argslist is a `typedargslist` or a `varargslist`. - if first.type == 'tfpdef': - children = [first] - else: - children = first.children - new_children = [] - start = 0 - # Start with offset 1, because the end is higher. - for end, child in enumerate(children + [None], 1): - if child is None or child == ',': - param_children = children[start:end] - if param_children: # Could as well be comma and then end. - if param_children[0] == '*' and param_children[1] == ',' \ - or check_python2_nested_param(param_children[0]): - for p in param_children: - p.parent = parent - new_children += param_children - else: - new_children.append(Param(param_children, parent)) - start = end - return new_children - - -class Function(ClassOrFunc): - """ - Used to store the parsed contents of a python function. - - Children:: - - 0. - 1. - 2. parameter list (including open-paren and close-paren s) - 3. or 5. - 4. or 6. Node() representing function body - 3. -> (if annotation is also present) - 4. annotation (if present) - """ - type = 'funcdef' - - def __init__(self, children): - super(Function, self).__init__(children) - parameters = self.children[2] # After `def foo` - parameters.children[1:-1] = _create_params(parameters, parameters.children[1:-1]) - - def _get_param_nodes(self): - return self.children[2].children - - def get_params(self): - """ - Returns a list of `Param()`. - """ - return [p for p in self._get_param_nodes() if p.type == 'param'] - - @property - def name(self): - return self.children[1] # First token after `def` - - def iter_yield_exprs(self): - """ - Returns a generator of `yield_expr`. - """ - def scan(children): - for element in children: - if element.type in ('classdef', 'funcdef', 'lambdef'): - continue - - try: - nested_children = element.children - except AttributeError: - if element.value == 'yield': - if element.parent.type == 'yield_expr': - yield element.parent - else: - yield element - else: - for result in scan(nested_children): - yield result - - return scan(self.children) - - def iter_return_stmts(self): - """ - Returns a generator of `return_stmt`. - """ - def scan(children): - for element in children: - if element.type == 'return_stmt' \ - or element.type == 'keyword' and element.value == 'return': - yield element - if element.type in _RETURN_STMT_CONTAINERS: - for e in scan(element.children): - yield e - - return scan(self.children) - - def iter_raise_stmts(self): - """ - Returns a generator of `raise_stmt`. Includes raise statements inside try-except blocks - """ - def scan(children): - for element in children: - if element.type == 'raise_stmt' \ - or element.type == 'keyword' and element.value == 'raise': - yield element - if element.type in _RETURN_STMT_CONTAINERS: - for e in scan(element.children): - yield e - - return scan(self.children) - - def is_generator(self): - """ - :return bool: Checks if a function is a generator or not. - """ - return next(self.iter_yield_exprs(), None) is not None - - @property - def annotation(self): - """ - Returns the test node after `->` or `None` if there is no annotation. - """ - try: - if self.children[3] == "->": - return self.children[4] - assert self.children[3] == ":" - return None - except IndexError: - return None - -class Lambda(Function): - """ - Lambdas are basically trimmed functions, so give it the same interface. - - Children:: - - 0. - *. for each argument x - -2. - -1. Node() representing body - """ - type = 'lambdef' - __slots__ = () - - def __init__(self, children): - # We don't want to call the Function constructor, call its parent. - super(Function, self).__init__(children) - # Everything between `lambda` and the `:` operator is a parameter. - self.children[1:-2] = _create_params(self, self.children[1:-2]) - - @property - def name(self): - """ - Raises an AttributeError. Lambdas don't have a defined name. - """ - raise AttributeError("lambda is not named.") - - def _get_param_nodes(self): - return self.children[1:-2] - - @property - def annotation(self): - """ - Returns `None`, lambdas don't have annotations. - """ - return None - - def __repr__(self): - return "<%s@%s>" % (self.__class__.__name__, self.start_pos) - - -class Flow(PythonBaseNode): - __slots__ = () - - -class IfStmt(Flow): - type = 'if_stmt' - __slots__ = () - - def get_test_nodes(self): - """ - E.g. returns all the `test` nodes that are named as x, below: - - if x: - pass - elif x: - pass - """ - for i, c in enumerate(self.children): - if c in ('elif', 'if'): - yield self.children[i + 1] - - def get_corresponding_test_node(self, node): - """ - Searches for the branch in which the node is and returns the - corresponding test node (see function above). However if the node is in - the test node itself and not in the suite return None. - """ - start_pos = node.start_pos - for check_node in reversed(list(self.get_test_nodes())): - if check_node.start_pos < start_pos: - if start_pos < check_node.end_pos: - return None - # In this case the node is within the check_node itself, - # not in the suite - else: - return check_node - - def is_node_after_else(self, node): - """ - Checks if a node is defined after `else`. - """ - for c in self.children: - if c == 'else': - if node.start_pos > c.start_pos: - return True - else: - return False - - -class WhileStmt(Flow): - type = 'while_stmt' - __slots__ = () - - -class ForStmt(Flow): - type = 'for_stmt' - __slots__ = () - - def get_testlist(self): - """ - Returns the input node ``y`` from: ``for x in y:``. - """ - return self.children[3] - - def get_defined_names(self): - return _defined_names(self.children[1]) - - -class TryStmt(Flow): - type = 'try_stmt' - __slots__ = () - - def get_except_clause_tests(self): - """ - Returns the ``test`` nodes found in ``except_clause`` nodes. - Returns ``[None]`` for except clauses without an exception given. - """ - for node in self.children: - if node.type == 'except_clause': - yield node.children[1] - elif node == 'except': - yield None - - -class WithStmt(Flow): - type = 'with_stmt' - __slots__ = () - - def get_defined_names(self): - """ - Returns the a list of `Name` that the with statement defines. The - defined names are set after `as`. - """ - names = [] - for with_item in self.children[1:-2:2]: - # Check with items for 'as' names. - if with_item.type == 'with_item': - names += _defined_names(with_item.children[2]) - return names - - def get_test_node_from_name(self, name): - node = name.parent - if node.type != 'with_item': - raise ValueError('The name is not actually part of a with statement.') - return node.children[0] - - -class Import(PythonBaseNode): - __slots__ = () - - def get_path_for_name(self, name): - """ - The path is the list of names that leads to the searched name. - - :return list of Name: - """ - try: - # The name may be an alias. If it is, just map it back to the name. - name = self._aliases()[name] - except KeyError: - pass - - for path in self.get_paths(): - if name in path: - return path[:path.index(name) + 1] - raise ValueError('Name should be defined in the import itself') - - def is_nested(self): - return False # By default, sub classes may overwrite this behavior - - def is_star_import(self): - return self.children[-1] == '*' - - -class ImportFrom(Import): - type = 'import_from' - __slots__ = () - - def get_defined_names(self): - """ - Returns the a list of `Name` that the import defines. The - defined names are set after `import` or in case an alias - `as` - is - present that name is returned. - """ - return [alias or name for name, alias in self._as_name_tuples()] - - def _aliases(self): - """Mapping from alias to its corresponding name.""" - return dict((alias, name) for name, alias in self._as_name_tuples() - if alias is not None) - - def get_from_names(self): - for n in self.children[1:]: - if n not in ('.', '...'): - break - if n.type == 'dotted_name': # from x.y import - return n.children[::2] - elif n == 'import': # from . import - return [] - else: # from x import - return [n] - - @property - def level(self): - """The level parameter of ``__import__``.""" - level = 0 - for n in self.children[1:]: - if n in ('.', '...'): - level += len(n.value) - else: - break - return level - - def _as_name_tuples(self): - last = self.children[-1] - if last == ')': - last = self.children[-2] - elif last == '*': - return # No names defined directly. - - if last.type == 'import_as_names': - as_names = last.children[::2] - else: - as_names = [last] - for as_name in as_names: - if as_name.type == 'name': - yield as_name, None - else: - yield as_name.children[::2] # yields x, y -> ``x as y`` - - def get_paths(self): - """ - The import paths defined in an import statement. Typically an array - like this: ``[, ]``. - - :return list of list of Name: - """ - dotted = self.get_from_names() - - if self.children[-1] == '*': - return [dotted] - return [dotted + [name] for name, alias in self._as_name_tuples()] - - -class ImportName(Import): - """For ``import_name`` nodes. Covers normal imports without ``from``.""" - type = 'import_name' - __slots__ = () - - def get_defined_names(self): - """ - Returns the a list of `Name` that the import defines. The defined names - is always the first name after `import` or in case an alias - `as` - is - present that name is returned. - """ - return [alias or path[0] for path, alias in self._dotted_as_names()] - - @property - def level(self): - """The level parameter of ``__import__``.""" - return 0 # Obviously 0 for imports without from. - - def get_paths(self): - return [path for path, alias in self._dotted_as_names()] - - def _dotted_as_names(self): - """Generator of (list(path), alias) where alias may be None.""" - dotted_as_names = self.children[1] - if dotted_as_names.type == 'dotted_as_names': - as_names = dotted_as_names.children[::2] - else: - as_names = [dotted_as_names] - - for as_name in as_names: - if as_name.type == 'dotted_as_name': - alias = as_name.children[2] - as_name = as_name.children[0] - else: - alias = None - if as_name.type == 'name': - yield [as_name], alias - else: - # dotted_names - yield as_name.children[::2], alias - - def is_nested(self): - """ - This checks for the special case of nested imports, without aliases and - from statement:: - - import foo.bar - """ - return bool([1 for path, alias in self._dotted_as_names() - if alias is None and len(path) > 1]) - - def _aliases(self): - """ - :return list of Name: Returns all the alias - """ - return dict((alias, path[-1]) for path, alias in self._dotted_as_names() - if alias is not None) - - -class KeywordStatement(PythonBaseNode): - """ - For the following statements: `assert`, `del`, `global`, `nonlocal`, - `raise`, `return`, `yield`, `return`, `yield`. - - `pass`, `continue` and `break` are not in there, because they are just - simple keywords and the parser reduces it to a keyword. - """ - __slots__ = () - - @property - def type(self): - """ - Keyword statements start with the keyword and end with `_stmt`. You can - crosscheck this with the Python grammar. - """ - return '%s_stmt' % self.keyword - - @property - def keyword(self): - return self.children[0].value - - -class AssertStmt(KeywordStatement): - __slots__ = () - - @property - def assertion(self): - return self.children[1] - - -class GlobalStmt(KeywordStatement): - __slots__ = () - - def get_global_names(self): - return self.children[1::2] - - -class ReturnStmt(KeywordStatement): - __slots__ = () - - -class YieldExpr(PythonBaseNode): - type = 'yield_expr' - __slots__ = () - - -def _defined_names(current): - """ - A helper function to find the defined names in statements, for loops and - list comprehensions. - """ - names = [] - if current.type in ('testlist_star_expr', 'testlist_comp', 'exprlist', 'testlist'): - for child in current.children[::2]: - names += _defined_names(child) - elif current.type in ('atom', 'star_expr'): - names += _defined_names(current.children[1]) - elif current.type in ('power', 'atom_expr'): - if current.children[-2] != '**': # Just if there's no operation - trailer = current.children[-1] - if trailer.children[0] == '.': - names.append(trailer.children[1]) - else: - names.append(current) - return names - - -class ExprStmt(PythonBaseNode, DocstringMixin): - type = 'expr_stmt' - __slots__ = () - - def get_defined_names(self): - """ - Returns a list of `Name` defined before the `=` sign. - """ - names = [] - if self.children[1].type == 'annassign': - names = _defined_names(self.children[0]) - return [ - name - for i in range(0, len(self.children) - 2, 2) - if '=' in self.children[i + 1].value - for name in _defined_names(self.children[i]) - ] + names - - def get_rhs(self): - """Returns the right-hand-side of the equals.""" - return self.children[-1] - - def yield_operators(self): - """ - Returns a generator of `+=`, `=`, etc. or None if there is no operation. - """ - first = self.children[1] - if first.type == 'annassign': - if len(first.children) <= 2: - return # No operator is available, it's just PEP 484. - - first = first.children[2] - yield first - - for operator in self.children[3::2]: - yield operator - - -class Param(PythonBaseNode): - """ - It's a helper class that makes business logic with params much easier. The - Python grammar defines no ``param`` node. It defines it in a different way - that is not really suited to working with parameters. - """ - type = 'param' - - def __init__(self, children, parent): - super(Param, self).__init__(children) - self.parent = parent - for child in children: - child.parent = self - - @property - def star_count(self): - """ - Is `0` in case of `foo`, `1` in case of `*foo` or `2` in case of - `**foo`. - """ - first = self.children[0] - if first in ('*', '**'): - return len(first.value) - return 0 - - @property - def default(self): - """ - The default is the test node that appears after the `=`. Is `None` in - case no default is present. - """ - has_comma = self.children[-1] == ',' - try: - if self.children[-2 - int(has_comma)] == '=': - return self.children[-1 - int(has_comma)] - except IndexError: - return None - - @property - def annotation(self): - """ - The default is the test node that appears after `:`. Is `None` in case - no annotation is present. - """ - tfpdef = self._tfpdef() - if tfpdef.type == 'tfpdef': - assert tfpdef.children[1] == ":" - assert len(tfpdef.children) == 3 - annotation = tfpdef.children[2] - return annotation - else: - return None - - def _tfpdef(self): - """ - tfpdef: see e.g. grammar36.txt. - """ - offset = int(self.children[0] in ('*', '**')) - return self.children[offset] - - @property - def name(self): - """ - The `Name` leaf of the param. - """ - if self._tfpdef().type == 'tfpdef': - return self._tfpdef().children[0] - else: - return self._tfpdef() - - def get_defined_names(self): - return [self.name] - - @property - def position_index(self): - """ - Property for the positional index of a paramter. - """ - index = self.parent.children.index(self) - try: - keyword_only_index = self.parent.children.index('*') - if index > keyword_only_index: - # Skip the ` *, ` - index -= 2 - except ValueError: - pass - return index - 1 - - def get_parent_function(self): - """ - Returns the function/lambda of a parameter. - """ - return search_ancestor(self, 'funcdef', 'lambdef') - - def get_code(self, include_prefix=True, include_comma=True): - """ - Like all the other get_code functions, but includes the param - `include_comma`. - - :param include_comma bool: If enabled includes the comma in the string output. - """ - if include_comma: - return super(Param, self).get_code(include_prefix) - - children = self.children - if children[-1] == ',': - children = children[:-1] - return self._get_code_for_children( - children, - include_prefix=include_prefix - ) - - def __repr__(self): - default = '' if self.default is None else '=%s' % self.default.get_code() - return '<%s: %s>' % (type(self).__name__, str(self._tfpdef()) + default) - - -class CompFor(PythonBaseNode): - type = 'comp_for' - __slots__ = () - - def get_defined_names(self): - """ - Returns the a list of `Name` that the comprehension defines. - """ - # allow async for - return _defined_names(self.children[self.children.index('for') + 1]) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/tree.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/tree.py deleted file mode 100644 index 72a1494..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/tree.py +++ /dev/null @@ -1,364 +0,0 @@ -from abc import abstractmethod, abstractproperty -from parso._compatibility import utf8_repr, encoding, py_version - - -def search_ancestor(node, *node_types): - """ - Recursively looks at the parents of a node and returns the first found node - that matches node_types. Returns ``None`` if no matching node is found. - - :param node: The ancestors of this node will be checked. - :param node_types: type names that are searched for. - :type node_types: tuple of str - """ - while True: - node = node.parent - if node is None or node.type in node_types: - return node - - -class NodeOrLeaf(object): - """ - The base class for nodes and leaves. - """ - __slots__ = () - type = None - ''' - The type is a string that typically matches the types of the grammar file. - ''' - - def get_root_node(self): - """ - Returns the root node of a parser tree. The returned node doesn't have - a parent node like all the other nodes/leaves. - """ - scope = self - while scope.parent is not None: - scope = scope.parent - return scope - - def get_next_sibling(self): - """ - Returns the node immediately following this node in this parent's - children list. If this node does not have a next sibling, it is None - """ - # Can't use index(); we need to test by identity - for i, child in enumerate(self.parent.children): - if child is self: - try: - return self.parent.children[i + 1] - except IndexError: - return None - - def get_previous_sibling(self): - """ - Returns the node immediately preceding this node in this parent's - children list. If this node does not have a previous sibling, it is - None. - None. - """ - # Can't use index(); we need to test by identity - for i, child in enumerate(self.parent.children): - if child is self: - if i == 0: - return None - return self.parent.children[i - 1] - - def get_previous_leaf(self): - """ - Returns the previous leaf in the parser tree. - Returns `None` if this is the first element in the parser tree. - """ - node = self - while True: - c = node.parent.children - i = c.index(node) - if i == 0: - node = node.parent - if node.parent is None: - return None - else: - node = c[i - 1] - break - - while True: - try: - node = node.children[-1] - except AttributeError: # A Leaf doesn't have children. - return node - - def get_next_leaf(self): - """ - Returns the next leaf in the parser tree. - Returns None if this is the last element in the parser tree. - """ - node = self - while True: - c = node.parent.children - i = c.index(node) - if i == len(c) - 1: - node = node.parent - if node.parent is None: - return None - else: - node = c[i + 1] - break - - while True: - try: - node = node.children[0] - except AttributeError: # A Leaf doesn't have children. - return node - - @abstractproperty - def start_pos(self): - """ - Returns the starting position of the prefix as a tuple, e.g. `(3, 4)`. - - :return tuple of int: (line, column) - """ - - @abstractproperty - def end_pos(self): - """ - Returns the end position of the prefix as a tuple, e.g. `(3, 4)`. - - :return tuple of int: (line, column) - """ - - @abstractmethod - def get_start_pos_of_prefix(self): - """ - Returns the start_pos of the prefix. This means basically it returns - the end_pos of the last prefix. The `get_start_pos_of_prefix()` of the - prefix `+` in `2 + 1` would be `(1, 1)`, while the start_pos is - `(1, 2)`. - - :return tuple of int: (line, column) - """ - - @abstractmethod - def get_first_leaf(self): - """ - Returns the first leaf of a node or itself if this is a leaf. - """ - - @abstractmethod - def get_last_leaf(self): - """ - Returns the last leaf of a node or itself if this is a leaf. - """ - - @abstractmethod - def get_code(self, include_prefix=True): - """ - Returns the code that was input the input for the parser for this node. - - :param include_prefix: Removes the prefix (whitespace and comments) of - e.g. a statement. - """ - - -class Leaf(NodeOrLeaf): - ''' - Leafs are basically tokens with a better API. Leafs exactly know where they - were defined and what text preceeds them. - ''' - __slots__ = ('value', 'parent', 'line', 'column', 'prefix') - - def __init__(self, value, start_pos, prefix=''): - self.value = value - ''' - :py:func:`str` The value of the current token. - ''' - self.start_pos = start_pos - self.prefix = prefix - ''' - :py:func:`str` Typically a mixture of whitespace and comments. Stuff - that is syntactically irrelevant for the syntax tree. - ''' - self.parent = None - ''' - The parent :class:`BaseNode` of this leaf. - ''' - - @property - def start_pos(self): - return self.line, self.column - - @start_pos.setter - def start_pos(self, value): - self.line = value[0] - self.column = value[1] - - def get_start_pos_of_prefix(self): - previous_leaf = self.get_previous_leaf() - if previous_leaf is None: - return self.line - self.prefix.count('\n'), 0 # It's the first leaf. - return previous_leaf.end_pos - - def get_first_leaf(self): - return self - - def get_last_leaf(self): - return self - - def get_code(self, include_prefix=True): - if include_prefix: - return self.prefix + self.value - else: - return self.value - - @property - def end_pos(self): - lines = self.value.split('\n') - end_pos_line = self.line + len(lines) - 1 - # Check for multiline token - if self.line == end_pos_line: - end_pos_column = self.column + len(lines[-1]) - else: - end_pos_column = len(lines[-1]) - return end_pos_line, end_pos_column - - @utf8_repr - def __repr__(self): - value = self.value - if not value: - value = self.type - return "<%s: %s>" % (type(self).__name__, value) - - -class TypedLeaf(Leaf): - __slots__ = ('type',) - def __init__(self, type, value, start_pos, prefix=''): - super(TypedLeaf, self).__init__(value, start_pos, prefix) - self.type = type - - -class BaseNode(NodeOrLeaf): - """ - The super class for all nodes. - A node has children, a type and possibly a parent node. - """ - __slots__ = ('children', 'parent') - type = None - - def __init__(self, children): - for c in children: - c.parent = self - self.children = children - """ - A list of :class:`NodeOrLeaf` child nodes. - """ - self.parent = None - ''' - The parent :class:`BaseNode` of this leaf. - None if this is the root node. - ''' - - @property - def start_pos(self): - return self.children[0].start_pos - - def get_start_pos_of_prefix(self): - return self.children[0].get_start_pos_of_prefix() - - @property - def end_pos(self): - return self.children[-1].end_pos - - def _get_code_for_children(self, children, include_prefix): - if include_prefix: - return "".join(c.get_code() for c in children) - else: - first = children[0].get_code(include_prefix=False) - return first + "".join(c.get_code() for c in children[1:]) - - def get_code(self, include_prefix=True): - return self._get_code_for_children(self.children, include_prefix) - - def get_leaf_for_position(self, position, include_prefixes=False): - """ - Get the :py:class:`parso.tree.Leaf` at ``position`` - - :param tuple position: A position tuple, row, column. Rows start from 1 - :param bool include_prefixes: If ``False``, ``None`` will be returned if ``position`` falls - on whitespace or comments before a leaf - :return: :py:class:`parso.tree.Leaf` at ``position``, or ``None`` - """ - def binary_search(lower, upper): - if lower == upper: - element = self.children[lower] - if not include_prefixes and position < element.start_pos: - # We're on a prefix. - return None - # In case we have prefixes, a leaf always matches - try: - return element.get_leaf_for_position(position, include_prefixes) - except AttributeError: - return element - - - index = int((lower + upper) / 2) - element = self.children[index] - if position <= element.end_pos: - return binary_search(lower, index) - else: - return binary_search(index + 1, upper) - - if not ((1, 0) <= position <= self.children[-1].end_pos): - raise ValueError('Please provide a position that exists within this node.') - return binary_search(0, len(self.children) - 1) - - def get_first_leaf(self): - return self.children[0].get_first_leaf() - - def get_last_leaf(self): - return self.children[-1].get_last_leaf() - - @utf8_repr - def __repr__(self): - code = self.get_code().replace('\n', ' ').strip() - if not py_version >= 30: - code = code.encode(encoding, 'replace') - return "<%s: %s@%s,%s>" % \ - (type(self).__name__, code, self.start_pos[0], self.start_pos[1]) - - -class Node(BaseNode): - """Concrete implementation for interior nodes.""" - __slots__ = ('type',) - - def __init__(self, type, children): - super(Node, self).__init__(children) - self.type = type - - def __repr__(self): - return "%s(%s, %r)" % (self.__class__.__name__, self.type, self.children) - - -class ErrorNode(BaseNode): - """ - A node that containes valid nodes/leaves that we're follow by a token that - was invalid. This basically means that the leaf after this node is where - Python would mark a syntax error. - """ - __slots__ = () - type = 'error_node' - - -class ErrorLeaf(Leaf): - """ - A leaf that is either completely invalid in a language (like `$` in Python) - or is invalid at that position. Like the star in `1 +* 1`. - """ - __slots__ = ('original_type',) - type = 'error_leaf' - - def __init__(self, original_type, value, start_pos, prefix=''): - super(ErrorLeaf, self).__init__(value, start_pos, prefix) - self.original_type = original_type - - def __repr__(self): - return "<%s: %s:%s, %s>" % \ - (type(self).__name__, self.original_type, repr(self.value), self.start_pos) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/utils.py b/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/utils.py deleted file mode 100644 index a4801b9..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/parso-0.1.1-py3.6.egg/parso/utils.py +++ /dev/null @@ -1,156 +0,0 @@ -from collections import namedtuple -import re -import sys -from ast import literal_eval - -from parso._compatibility import unicode, total_ordering - - -Version = namedtuple('Version', 'major, minor, micro') - - -def split_lines(string, keepends=False): - r""" - Intended for Python code. In contrast to Python's :py:meth:`str.splitlines`, - looks at form feeds and other special characters as normal text. Just - splits ``\n`` and ``\r\n``. - Also different: Returns ``[""]`` for an empty string input. - - In Python 2.7 form feeds are used as normal characters when using - str.splitlines. However in Python 3 somewhere there was a decision to split - also on form feeds. - """ - if keepends: - lst = string.splitlines(True) - - # We have to merge lines that were broken by form feed characters. - merge = [] - for i, line in enumerate(lst): - if line.endswith('\f'): - merge.append(i) - - for index in reversed(merge): - try: - lst[index] = lst[index] + lst[index + 1] - del lst[index + 1] - except IndexError: - # index + 1 can be empty and therefore there's no need to - # merge. - pass - - # The stdlib's implementation of the end is inconsistent when calling - # it with/without keepends. One time there's an empty string in the - # end, one time there's none. - if string.endswith('\n') or string == '': - lst.append('') - return lst - else: - return re.split('\n|\r\n', string) - - -def python_bytes_to_unicode(source, encoding='utf-8', errors='strict'): - """ - Checks for unicode BOMs and PEP 263 encoding declarations. Then returns a - unicode object like in :py:meth:`bytes.decode`. - - :param encoding: See :py:meth:`bytes.decode` documentation. - :param errors: See :py:meth:`bytes.decode` documentation. ``errors`` can be - ``'strict'``, ``'replace'`` or ``'ignore'``. - """ - def detect_encoding(): - """ - For the implementation of encoding definitions in Python, look at: - - http://www.python.org/dev/peps/pep-0263/ - - http://docs.python.org/2/reference/lexical_analysis.html#encoding-declarations - """ - byte_mark = literal_eval(r"b'\xef\xbb\xbf'") - if source.startswith(byte_mark): - # UTF-8 byte-order mark - return 'utf-8' - - first_two_lines = re.match(br'(?:[^\n]*\n){0,2}', source).group(0) - possible_encoding = re.search(br"coding[=:]\s*([-\w.]+)", - first_two_lines) - if possible_encoding: - return possible_encoding.group(1) - else: - # the default if nothing else has been set -> PEP 263 - return encoding - - if isinstance(source, unicode): - # only cast str/bytes - return source - - encoding = detect_encoding() - if not isinstance(encoding, unicode): - encoding = unicode(encoding, 'utf-8', 'replace') - - # Cast to unicode - return unicode(source, encoding, errors) - - -def version_info(): - """ - Returns a namedtuple of parso's version, similar to Python's - ``sys.version_info``. - """ - from parso import __version__ - tupl = re.findall(r'[a-z]+|\d+', __version__) - return Version(*[x if i == 3 else int(x) for i, x in enumerate(tupl)]) - - -def _parse_version(version): - match = re.match(r'(\d+)(?:\.(\d)(?:\.\d+)?)?$', version) - if match is None: - raise ValueError('The given version is not in the right format. ' - 'Use something like "3.2" or "3".') - - major = int(match.group(1)) - minor = match.group(2) - if minor is None: - # Use the latest Python in case it's not exactly defined, because the - # grammars are typically backwards compatible? - if major == 2: - minor = "7" - elif major == 3: - minor = "6" - else: - raise NotImplementedError("Sorry, no support yet for those fancy new/old versions.") - minor = int(minor) - return PythonVersionInfo(major, minor) - - -@total_ordering -class PythonVersionInfo(namedtuple('Version', 'major, minor')): - def __gt__(self, other): - if isinstance(other, tuple): - if len(other) != 2: - raise ValueError("Can only compare to tuples of length 2.") - return (self.major, self.minor) > other - super(PythonVersionInfo, self).__gt__(other) - - return (self.major, self.minor) - - def __eq__(self, other): - if isinstance(other, tuple): - if len(other) != 2: - raise ValueError("Can only compare to tuples of length 2.") - return (self.major, self.minor) == other - super(PythonVersionInfo, self).__eq__(other) - - def __ne__(self, other): - return not self.__eq__(other) - - -def parse_version_string(version=None): - """ - Checks for a valid version number (e.g. `3.2` or `2.7.1` or `3`) and - returns a corresponding version info that is always two characters long in - decimal. - """ - if version is None: - version = '%s.%s' % sys.version_info[:2] - if not isinstance(version, (unicode, str)): - raise TypeError("version must be a string like 3.2.") - - return _parse_version(version) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/DESCRIPTION.rst b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/DESCRIPTION.rst deleted file mode 100644 index a8bb0e6..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/DESCRIPTION.rst +++ /dev/null @@ -1,125 +0,0 @@ - -.. |travis| image:: https://travis-ci.org/proofit404/service-factory.png - :target: https://travis-ci.org/proofit404/service-factory - :alt: Build Status - -.. |coveralls| image:: https://coveralls.io/repos/proofit404/service-factory/badge.png - :target: https://coveralls.io/r/proofit404/service-factory - :alt: Coverage Status - -.. |requires| image:: https://requires.io/github/proofit404/service-factory/requirements.svg - :target: https://requires.io/github/proofit404/service-factory/requirements - :alt: Requirements Status - -.. |landscape| image:: https://landscape.io/github/proofit404/service-factory/master/landscape.svg - :target: https://landscape.io/github/proofit404/service-factory/master - :alt: Code Health - -=============== -service-factory -=============== - -|travis| |coveralls| |requires| |landscape| - -JSON RPC service factory for Python. - -Usage ------ - -Service factory in a nutshell: - -.. code:: python - - from service_factory import service_factory - - def add(one, two): - """Add two numbers.""" - return one + two - - def mul(one, two): - """Multiply two numbers.""" - return one * two - - app = [add, mul] - - if __name__ == '__main__': - service_factory(app, host='localhost', port=0) - -Run this as usual python file: - -.. code:: bash - - $ python calc.py - service factory starts at port 9001 - -See it works: - -.. code:: bash - - $ curl -X POST -d '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}' -H 'Content-Type:application/json;' http://localhost:9001/ - -You can use any callable list from arbitrary module to run your -application: - -.. code:: bash - - $ python -m service_factory calc:app --host=localhost --port=auto - # or - $ service_factory calc:app --host=localhost --port=auto - -TODO ----- - -* process all errors codes -* batch processing -* notifications -* WSGI provider -* tornado provider -* aiohttp provider -* --port-file option -* console entry point -* make providers act as context managers -* ``user_error(code, message, data=None)`` -* WSGI authorization -* sphinx docs -* Django user permissions for rpc method -* Celery service implementation -* RQ service implementation - -.. :changelog: - -Changelog ---------- - -0.1.5 (2016-10-09) -++++++++++++++++++ - -- Zip unsafe for setuptools. - -0.1.4 (2016-09-02) -++++++++++++++++++ - -- Use 0 port value for automatic port detection. - -0.1.3 (2016-08-25) -++++++++++++++++++ - -- Remove ``six`` library from install requires. - -0.1.2 (2015-03-05) -++++++++++++++++++ - -- Remove allowed hosts parameters from ``service_factory`` function. - -0.1.1 (2015-03-05) -++++++++++++++++++ - -- Remove wildcard parameters from ``service_factory`` function. This - fix ``provider_cls`` resolution issue. - -0.1.0 (2015-03-04) -++++++++++++++++++ - -- Initial release. - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/PKG-INFO b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/PKG-INFO deleted file mode 100644 index 4cd6c29..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/PKG-INFO +++ /dev/null @@ -1,145 +0,0 @@ -Metadata-Version: 2.0 -Name: service-factory -Version: 0.1.5 -Summary: JSON RPC service factory for Python. -Home-page: https://github.com/proofit404/service-factory -Author: Artem Malyshev -Author-email: proofit404@gmail.com -License: GPL3 -Platform: any -Classifier: Development Status :: 4 - Beta -Classifier: Intended Audience :: Developers -Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3) -Classifier: Programming Language :: Python :: 2 -Classifier: Programming Language :: Python :: 2.6 -Classifier: Programming Language :: Python :: 2.7 -Classifier: Programming Language :: Python :: 3 -Classifier: Programming Language :: Python :: 3.3 -Classifier: Programming Language :: Python :: 3.4 -Classifier: Topic :: Software Development - - -.. |travis| image:: https://travis-ci.org/proofit404/service-factory.png - :target: https://travis-ci.org/proofit404/service-factory - :alt: Build Status - -.. |coveralls| image:: https://coveralls.io/repos/proofit404/service-factory/badge.png - :target: https://coveralls.io/r/proofit404/service-factory - :alt: Coverage Status - -.. |requires| image:: https://requires.io/github/proofit404/service-factory/requirements.svg - :target: https://requires.io/github/proofit404/service-factory/requirements - :alt: Requirements Status - -.. |landscape| image:: https://landscape.io/github/proofit404/service-factory/master/landscape.svg - :target: https://landscape.io/github/proofit404/service-factory/master - :alt: Code Health - -=============== -service-factory -=============== - -|travis| |coveralls| |requires| |landscape| - -JSON RPC service factory for Python. - -Usage ------ - -Service factory in a nutshell: - -.. code:: python - - from service_factory import service_factory - - def add(one, two): - """Add two numbers.""" - return one + two - - def mul(one, two): - """Multiply two numbers.""" - return one * two - - app = [add, mul] - - if __name__ == '__main__': - service_factory(app, host='localhost', port=0) - -Run this as usual python file: - -.. code:: bash - - $ python calc.py - service factory starts at port 9001 - -See it works: - -.. code:: bash - - $ curl -X POST -d '{"jsonrpc": "2.0", "method": "add", "params": [1, 2], "id": 1}' -H 'Content-Type:application/json;' http://localhost:9001/ - -You can use any callable list from arbitrary module to run your -application: - -.. code:: bash - - $ python -m service_factory calc:app --host=localhost --port=auto - # or - $ service_factory calc:app --host=localhost --port=auto - -TODO ----- - -* process all errors codes -* batch processing -* notifications -* WSGI provider -* tornado provider -* aiohttp provider -* --port-file option -* console entry point -* make providers act as context managers -* ``user_error(code, message, data=None)`` -* WSGI authorization -* sphinx docs -* Django user permissions for rpc method -* Celery service implementation -* RQ service implementation - -.. :changelog: - -Changelog ---------- - -0.1.5 (2016-10-09) -++++++++++++++++++ - -- Zip unsafe for setuptools. - -0.1.4 (2016-09-02) -++++++++++++++++++ - -- Use 0 port value for automatic port detection. - -0.1.3 (2016-08-25) -++++++++++++++++++ - -- Remove ``six`` library from install requires. - -0.1.2 (2015-03-05) -++++++++++++++++++ - -- Remove allowed hosts parameters from ``service_factory`` function. - -0.1.1 (2015-03-05) -++++++++++++++++++ - -- Remove wildcard parameters from ``service_factory`` function. This - fix ``provider_cls`` resolution issue. - -0.1.0 (2015-03-04) -++++++++++++++++++ - -- Initial release. - - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/RECORD b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/RECORD deleted file mode 100644 index 06ee6d1..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/RECORD +++ /dev/null @@ -1,15 +0,0 @@ -service_factory/__init__.py,sha256=qJHg780ZCxGptZpYrBIiw7wV5VSYASi-6uCkfJq2Szw,352 -service_factory/compat.py,sha256=EGD9CEJo1UQ5-HOKYgAmrB8cn3ktkZRxhDpn1o8Egq4,503 -service_factory/errors.py,sha256=3nAv684RdoH4iwe3RkxpLdx2b0cAHVbyJCVcBsDeSbA,1905 -service_factory/exceptions.py,sha256=gpm3N3k6E3nGYeqvHVsqYlu12e4DeYJRsILYB-eZcrE,423 -service_factory/factory.py,sha256=B0FZPGX9lV_9Szq-UKaY4bq5zBz0L6gjWixUzi0eM_E,956 -service_factory/service.py,sha256=jZnz5eoWHNDxM2L4BWKpxbhanb8ljYPyQtSNWTg4eXg,2901 -service_factory/validation.py,sha256=dLqpAM1SNuzpNX1mSzky11ZDHQIgCKVRgE69zd0dOg8,1299 -service_factory/providers/__init__.py,sha256=9bNT0AYhwP2ApaXpRPZxJNKc_vNcQnOahDyvwpdaxUM,92 -service_factory/providers/basehttp.py,sha256=UmKJH0iRgyDuvouHjNUClBVex6je1nGUgBoiSbjNe54,2328 -service_factory-0.1.5.dist-info/DESCRIPTION.rst,sha256=HyyAWuUfaJyIMdbCAzzZQ_CYBGtV0R8bVMSZIjHRE_E,2772 -service_factory-0.1.5.dist-info/METADATA,sha256=9pzo_d0UsghxFTEHPO8_mQ7FrxBkMuiJAPInRwDsHhc,3523 -service_factory-0.1.5.dist-info/RECORD,, -service_factory-0.1.5.dist-info/WHEEL,sha256=rNo05PbNqwnXiIHFsYm0m22u4Zm6YJtugFG2THx4w3g,92 -service_factory-0.1.5.dist-info/metadata.json,sha256=cOwbuzsNrbCBN93C5-BSGo0CfsZWAdyUUB7t3ZrCZqY,887 -service_factory-0.1.5.dist-info/top_level.txt,sha256=gt5UuhlXCDjkJP7XZDe5ulXUJOxZZI9iV4OB9uhJR-M,16 diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/WHEEL b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/WHEEL deleted file mode 100644 index bb7f7db..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/WHEEL +++ /dev/null @@ -1,5 +0,0 @@ -Wheel-Version: 1.0 -Generator: bdist_wheel (0.29.0) -Root-Is-Purelib: true -Tag: py3-none-any - diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/metadata.json b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/metadata.json deleted file mode 100644 index 2f8e1dd..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/metadata.json +++ /dev/null @@ -1 +0,0 @@ -{"classifiers": ["Development Status :: 4 - Beta", "Intended Audience :: Developers", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Programming Language :: Python :: 2", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.3", "Programming Language :: Python :: 3.4", "Topic :: Software Development"], "extensions": {"python.details": {"contacts": [{"email": "proofit404@gmail.com", "name": "Artem Malyshev", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "https://github.com/proofit404/service-factory"}}}, "generator": "bdist_wheel (0.29.0)", "license": "GPL3", "metadata_version": "2.0", "name": "service-factory", "platform": "any", "summary": "JSON RPC service factory for Python.", "version": "0.1.5"} \ No newline at end of file diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/top_level.txt b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/top_level.txt deleted file mode 100644 index 13d42f2..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/EGG-INFO/top_level.txt +++ /dev/null @@ -1 +0,0 @@ -service_factory diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__init__.py deleted file mode 100644 index b540fd0..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__init__.py +++ /dev/null @@ -1,17 +0,0 @@ -""" - service_factory - ~~~~~~~~~~~~~~~ - - JSON RPC service factory for Python. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) - -from .factory import service_factory - -__all__ = ['service_factory'] diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/__init__.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/__init__.cpython-36.pyc deleted file mode 100644 index b2aceda..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/__init__.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/compat.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/compat.cpython-36.pyc deleted file mode 100644 index 397bcf2..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/compat.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/errors.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/errors.cpython-36.pyc deleted file mode 100644 index 687f2e9..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/errors.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/exceptions.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/exceptions.cpython-36.pyc deleted file mode 100644 index 8efc5c9..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/exceptions.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/factory.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/factory.cpython-36.pyc deleted file mode 100644 index bbd2072..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/factory.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/service.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/service.cpython-36.pyc deleted file mode 100644 index 64ea1b3..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/service.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/validation.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/validation.cpython-36.pyc deleted file mode 100644 index a0b7952..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/__pycache__/validation.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/compat.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/compat.py deleted file mode 100644 index b65da4c..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/compat.py +++ /dev/null @@ -1,23 +0,0 @@ -""" - service_factory.compat - ~~~~~~~~~~~~~~~~~~~~~~ - - Python compatibility workarounds. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -__all__ = ['string_types', 'BaseHTTPRequestHandler', 'HTTPServer'] - - -try: - string_types = basestring -except NameError: - string_types = str - - -try: - from http.server import BaseHTTPRequestHandler, HTTPServer -except ImportError: - from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/errors.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/errors.py deleted file mode 100644 index dc85071..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/errors.py +++ /dev/null @@ -1,91 +0,0 @@ -""" - service_factory.errors - ~~~~~~~~~~~~~~~~~~~~~~ - - This module implements different errors emitters. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) -from json import dumps - -from .exceptions import ServiceException - - -def parse_error(): - """JSON-RPC parse error.""" - - response = { - 'jsonrpc': '2.0', - 'id': None, - 'error': { - 'code': -32700, - 'message': 'Parse error', - }, - } - raise ServiceException(400, dumps(response)) - - -def invalid_request(error): - """JSON-RPC invalid request error. - - :param error: request error - :type error: Exception - - """ - - response = { - 'jsonrpc': '2.0', - 'id': None, - 'error': { - 'code': -32600, - 'message': 'Invalid Request', - 'data': repr(error), - }, - } - raise ServiceException(400, dumps(response)) - - -def method_not_found(request_id): - """JSON-RPC method not found error. - - :param request_id: JSON-RPC request id - :type request_id: int or str or None - - """ - - response = { - 'jsonrpc': '2.0', - 'id': request_id, - 'error': { - 'code': -32601, - 'message': 'Method not found', - }, - } - raise ServiceException(400, dumps(response)) - - -def server_error(request_id, error): - """JSON-RPC server error. - - :param request_id: JSON-RPC request id - :type request_id: int or str or None - :param error: server error - :type error: Exception - - """ - - response = { - 'jsonrpc': '2.0', - 'id': request_id, - 'error': { - 'code': -32000, - 'message': 'Server error', - 'data': repr(error), - }, - } - raise ServiceException(500, dumps(response)) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/exceptions.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/exceptions.py deleted file mode 100644 index 8cd3dbe..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/exceptions.py +++ /dev/null @@ -1,19 +0,0 @@ -""" - service_factory.exceptions - ~~~~~~~~~~~~~~~~~~~~~~~~~~ - - This module contains exceptions raised by service factory. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) - - -class ServiceException(Exception): - """Exception occurred in running service.""" - - pass diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/factory.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/factory.py deleted file mode 100644 index 397406d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/factory.py +++ /dev/null @@ -1,34 +0,0 @@ -""" - service_factory.factory - ~~~~~~~~~~~~~~~~~~~~~~~ - - This module define service factory. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) - -from .providers.basehttp import HTTPServiceProvider -from .service import Service - - -def service_factory(app, host, port, - report_message='service factory port {port}', - provider_cls=HTTPServiceProvider): - """Create service, start server. - - :param app: application to instantiate a service - :param host: interface to bound provider - :param port: port to bound provider - :param report_message: message format to report port - :param provider_cls: server class provide a service - - """ - - service = Service(app) - server = provider_cls(service, host, port, report_message) - server.serve_forever() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__init__.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__init__.py deleted file mode 100644 index 56b7a20..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__pycache__/__init__.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__pycache__/__init__.cpython-36.pyc deleted file mode 100644 index 800e96b..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__pycache__/__init__.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__pycache__/basehttp.cpython-36.pyc b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__pycache__/basehttp.cpython-36.pyc deleted file mode 100644 index e6dd588..0000000 Binary files a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/__pycache__/basehttp.cpython-36.pyc and /dev/null differ diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/basehttp.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/basehttp.py deleted file mode 100644 index 1f1c85e..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/providers/basehttp.py +++ /dev/null @@ -1,84 +0,0 @@ -""" - service_factory.providers.basehttp - ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - - This module define service provider based on the BaseHTTPHandler. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) - -import socket -import sys -from traceback import print_exc - -from service_factory.compat import BaseHTTPRequestHandler, HTTPServer -from service_factory.errors import parse_error -from service_factory.exceptions import ServiceException - - -class HTTPRequestHandler(BaseHTTPRequestHandler): - - protocol_version = 'HTTP/1.1' - error_message_format = '' - - def log_request(self, *args): - """Ignore non error logging messages.""" - - pass - - def do_POST(self): - try: - content_len = self.headers.get('content-length') - if content_len and content_len.isdigit(): - raw_data = self.rfile.read(int(content_len)) - data = raw_data.decode('utf-8') - status, response = self.server.service(data) - else: - parse_error() - except ServiceException as error: - self.log_error('=' * 80) - print_exc() - status, response = error.args - - response = response.encode('utf-8') - self.send_response(status) - self.send_header("Content-Length", len(response)) - self.end_headers() - self.wfile.write(response) - - -class HTTPServiceProvider(HTTPServer): - """Base HTTP service provider.""" - - def __init__(self, service, host, port, - report_message='service factory port {port}'): - - self.service = service - self.host = host - self.port = port - self.report_message = report_message - self.bind() - self.report() - - def bind(self): - """Bind and activate HTTP server.""" - - HTTPServer.__init__(self, (self.host, self.port), HTTPRequestHandler) - self.port = self.server_port - - def report(self): - """Report startup info to stdout.""" - - print( - self.report_message.format( - service=self.service, - host=self.host, - port=self.port, - ) - ) - sys.stdout.flush() diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/service.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/service.py deleted file mode 100644 index 112cb00..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/service.py +++ /dev/null @@ -1,116 +0,0 @@ -""" - service_factory.service - ~~~~~~~~~~~~~~~~~~~~~~~ - - This module define service class. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) -from json import loads, dumps - -from .errors import ( - invalid_request, method_not_found, parse_error, server_error) -from .validation import ( - validate_version, validate_method, validate_params, validate_id) - - -class Service(object): - """Base Service. Provide application method access.""" - - def __init__(self, app): - """Service constructor. - - :param app: application definition - :type app: list of callable, dict of callable - - """ - - if isinstance(app, list): - self.app = dict((method.__name__, method) for method in app) - elif isinstance(app, dict): - self.app = app - - def __call__(self, arg): - """Perform jsonrpc call. - - :param arg: JSON-RPC request body - :type arg: str - :raises: ServiceException - - """ - - args = self.load_args(arg) - self.validate(args) - method = self.get_method(args) - result = self.apply(method, args) - response = self.make_response(args, result) - return 200, response - - def load_args(self, arg): - """Loads service args from string. - - :param arg: Request body - :raises: ServiceException - - """ - - try: - args = loads(arg) - except ValueError: - parse_error() - else: - return args - - def validate(self, request): - """Validate JSON-RPC request. - - :param request: RPC request object - :type request: dict - - """ - - try: - validate_version(request) - validate_method(request) - validate_params(request) - validate_id(request) - except (AssertionError, KeyError) as error: - invalid_request(error) - - def get_method(self, args): - """Get request method for service application.""" - - try: - method = self.app[args['method']] - except KeyError: - method_not_found(args['id']) - else: - return method - - def apply(self, method, args): - """Apply application method.""" - - try: - params = args['params'] - if isinstance(params, dict): - result = method(**params) - else: - result = method(*params) - except Exception as error: - server_error(args['id'], error) - else: - return result - - def make_response(self, args, result): - """Create response body from given result.""" - - return dumps({ - 'jsonrpc': '2.0', - 'id': args['id'], - 'result': result, - }) diff --git a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/validation.py b/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/validation.py deleted file mode 100644 index 03d294d..0000000 --- a/emacs/.emacs.d/anaconda-mode/0.1.9/service_factory-0.1.5-py3.6.egg/service_factory/validation.py +++ /dev/null @@ -1,52 +0,0 @@ -""" - service_factory.validation - ~~~~~~~~~~~~~~~~~~~~~~~~~~ - - This module implement JSON-RPC request validation. - - :copyright: (c) 2015-2016 by Artem Malyshev. - :license: GPL3, see LICENSE for more details. -""" - -from __future__ import ( - absolute_import, unicode_literals, division, print_function, -) - -from .compat import string_types - - -def validate_version(request): - """Validate request version.""" - - correct_version = request['jsonrpc'] == '2.0' - error = 'Incorrect version of the JSON-RPC protocol' - assert correct_version, error - - -def validate_method(request): - """Validate request method.""" - - correct_method = isinstance(request['method'], string_types) - error = 'Incorrect name of the method to be invoked' - assert correct_method, error - - -def validate_params(request): - """Validate request params.""" - - if 'params' in request: - correct_params = isinstance(request['params'], (list, dict)) - error = 'Incorrect parameter values' - assert correct_params, error - - -def validate_id(request): - """Validate request id.""" - - if 'id' in request: - correct_id = isinstance( - request['id'], - (string_types, int, None), - ) - error = 'Incorrect identifier' - assert correct_id, error diff --git a/emacs/.emacs.d/config.el b/emacs/.emacs.d/config.el index b5dce72..6e7245c 100644 --- a/emacs/.emacs.d/config.el +++ b/emacs/.emacs.d/config.el @@ -13,7 +13,13 @@ (use-package aggressive-indent) (use-package anaconda-mode) -;; (use-package auctex) throws error with use-package +(use-package auto-complete) +(use-package auto-complete-auctex +:defer t +:ensure t) +(use-package auctex +:defer t +:ensure t) (use-package counsel) (use-package eclim) (use-package flycheck) @@ -117,6 +123,10 @@ '(lambda () (setq org-src-fontify-natively t))) +(add-hook 'org-mode-hook + '(lambda () + (setq org-pretty-entities t))) + (add-hook 'org-mode-hook 'rainbow-delimiters-mode) (counsel-mode 1) diff --git a/emacs/.emacs.d/config.html b/emacs/.emacs.d/config.html deleted file mode 100644 index f563f6b..0000000 --- a/emacs/.emacs.d/config.html +++ /dev/null @@ -1,614 +0,0 @@ - - - -Emacs configure - - - - - - - - - - - - - -
-

Emacs configure

- -
-

1 Packages

-
-
-

1.1 Installed packages:

-
-
    -
  • aggressive-indent -
    • -
  • anaconda-mode -
    • -
  • auctex -
    • -
  • dash -
    • -
  • eclim -
    • -
  • epl -
    • -
  • f -
    • -
  • flycheck -
    • -
  • forest-blue-theme -
    • -
  • google-this -
    • -
  • highlight-indentation -
    • -
  • ivy -
    • -
  • ox-twbs -
    • -
  • pkg-info -
    • -
  • popup -
    • -
  • pythonic -
    • -
  • rainbow-delimiters -
    • -
  • rainbow-mode -
    • -
  • s -
    • -
  • smartparens -
    • -
  • yasnippet -
    • -
-
-
- -
-

1.2 Package Archives

-
-

-Adding the melpa package repository to Emacs. -

-
- -
(require 'package)
-(add-to-list 'package-archives 
-    '("melpa" . "http://melpa.org/packages/"))
-
-
-
-
-
-
-

2 Themes

-
-

-Using the Material-Theme. -

-
- -
(load-theme 'material t)
-
-
- -

-Changes the Emacs background to the terminals defaults. (Generally) -

-
- -
(add-hook 'window-setup-hook 
-      '(lambda () 
-	 (set-face-background 'default "unspecified-bg")))
-
-
-
-
- -
-

3 Functions

-
-
-

3.1 Cut/Copy and Paste by Boruch Baum

-
-
-

3.1.1 Copy

-
-

-Copy the marked area to the clipboard. -

-
- -
(defun copy-to-xclipboard(arg)
-  (interactive "P")
-  (cond
-   ((not (use-region-p))
-    (message "Nothing to yank to X-clipboard"))
-   ((and (not (display-graphic-p))
-	 (/= 0 (shell-command-on-region
-		(region-beginning) (region-end) "xsel -i -b")))
-    (error "Is program `xsel' installed?"))
-   (t
-    (when (display-graphic-p)
-      (call-interactively 'clipboard-kill-ring-save))
-    (message "Yanked region to X-clipboard")
-    (deactivate-mark))))
-
-
-
-
- -
-

3.1.2 Cut

-
-

-Cut the marked area to the clipboard. -

-
- -
(defun cut-to-xclipboard(arg)
-  (interactive "P")
-  (cond
-   ((not (use-region-p))
-    (message "Nothing to yank to X-clipboard"))
-   ((and (not (display-graphic-p))
-	 (/= 0 (shell-command-on-region
-		(region-beginning) (region-end) "xsel -i -b")))
-    (error "Is program `xsel' installed?"))
-   (t
-    (when (display-graphic-p)
-    (call-interactively 'clipboard-kill-ring-save))
-    (message "Yanked region to X-clipboard")
-    (kill-region  (region-beginning) (region-end))
-    (deactivate-mark))))
-
-
-
-
- -
-

3.1.3 Paste

-
-

-Paste from the clipboard. -

-
- -
(defun paste-from-xclipboard()
-  "Uses shell command `xsel -o' to paste from x-clipboard. With
-    one prefix arg, pastes from X-PRIMARY, and with two prefix args,
-    pastes from X-SECONDARY."
-  (interactive)
-  (if (display-graphic-p)
-      (clipboard-yank)
-    (let*
-	((opt (prefix-numeric-value current-prefix-arg))
-	 (opt (cond
-	       ((=  1 opt) "b")
-	       ((=  4 opt) "p")
-	       ((= 16 opt) "s"))))
-      (insert (shell-command-to-string (concat "xsel -o -" opt))))))
-
-
-
-
-
- -
-

3.2 Personal functions

-
-

-Go back to indentation, if you are at the indentation, go to beginning of the line instead. -

-
- -
(defun back-to-indentation-or-beginning () 
-"Go back to indentation, if at indentation go to beginning of line"
-(interactive)
- (if (= (point) (progn (back-to-indentation) (point)))
-     (beginning-of-line)))
-
-
- -

-Sets the background of Emacs in terminal-mode to the terminals. Doesn't change it in window -mode tho. -

-
- -
(defun transparent-terminal ()
-  (unless (display-graphic-p (selected-frame))
-    (set-face-background 'default "unspecified-bg" (selected-frame))))
-
-
-
-
-
-
-

4 Mode customisation

-
-
-

4.1 Window Modes

-
-
- -
(menu-bar-mode -1)
-
-
-
-
- -
-

4.2 Python

-
-
- -
(add-hook 'python-mode-hook 'anaconda-mode)
-(add-hook 'python-mode-hook 'anaconda-eldoc-mode)
-
-
-
-
-
-

4.3 LaTeX

-
-
- -
(require 'tex)
-(setq TeX-auto-save t)
-(setq TeX-parse-self t)
-(setq-default TeX-master nil)
-
-
-
-
- -
-

4.4 Org

-
-
- -
(require 'ox-twbs)
-
-
- -

-Use Evince as default pdf viewer. -

-
- -
(add-hook 'org-mode-hook
-      '(lambda ()
-	 (delete '("\\.pdf\\'" . default) org-file-apps)
-	 (add-to-list 'org-file-apps '("\\.pdf\\'" . "evince %s"))))
-
-
- -

-Activate Syntax Highlighting in Org-mode. -

-
- -
(add-hook 'org-mode-hook 
-      '(lambda () 
-	 (setq org-src-fontify-natively t)))
-
-
- -

-Add rainbow-delimiters in org-mode -

-
- -
(add-hook 'org-mode-hook 'rainbow-delimiters-mode)
-
-
-
-
-
-

4.5 Ivy

-
-
- -
(ivy-mode 1)
-
-
-
-
-
-

4.6 Parenthesis

-
-
- -
(require 'paren)
-(setq show-paren-style 'parenthesis)
-(show-paren-mode +1)
-
-
-
-
-
-

4.7 Highlight line

-
-

-Globaly highlight the current line in a slightly darker shade of grey. -

-
- -
(global-hl-line-mode 1)
-(set-face-background 'hl-line "#333333")
-(set-face-foreground 'highlight nil)
-
-
-
-
-
-

4.8 Yasnippet

-
-
- -
(require 'yasnippet)
-(setq yas-snippet-dirs
-  '("~/.emacs.d/snippets/"))
-(yas-global-mode 1)
-
-
-
-
- -
-

4.9 Personal mode

-
-
- -
(defvar my-keys-minor-mode-map
-  (let ((map (make-sparse-keymap)))
-    (define-key map (kbd "C-a") 'back-to-indentation-or-beginning)
-    (define-key map (kbd "C-c M-w") 'copy-to-xclipboard)
-    (define-key map (kbd "C-c C-w") 'cut-to-xclipboard)
-    (define-key map (kbd "C-c M-y") 'paste-from-xclipboard)
-    map)
-  "my-keys-minor-mode keymap.")
-
-(define-minor-mode my-keys-minor-mode
-  "A minor mode so that my key settings override annoying major modes."
-  :init-value t
-  :lighter " my-keys")
-
-(my-keys-minor-mode 1)
-
-
-
-
-
-
-
- - - diff --git a/emacs/.emacs.d/config.org b/emacs/.emacs.d/config.org index bddde14..410d66b 100644 --- a/emacs/.emacs.d/config.org +++ b/emacs/.emacs.d/config.org @@ -13,7 +13,7 @@ * Packages A list of installed packages and details about them. ** Package Archives -Adding the melpa package repository to Emacs. + Adding the melpa package repository to Emacs. #+BEGIN_SRC emacs-lisp (require 'package) (add-to-list 'package-archives @@ -21,23 +21,8 @@ Adding the melpa package repository to Emacs. (package-initialize) #+END_SRC ** Installed packages: - - aggressive-indent - Minor mode to aggressively keep your code always indented - - anaconda-mode - Code navigation, documentation lookup and completion for Python - - auctex - Integrated environment for *TeX* - - counsel - Various completion functions using Ivy - - eclim - An interface to the Eclipse IDE. - - flycheck - On-the-fly syntax checking - - forest-blue-theme - Emacs theme with a dark background. - - google-this - A set of functions and bindings to google under point. - - ivy - Incremental Vertical completYon - - material-theme - A Theme based on the colors of the Google Material Design - - ox-twbs - Bootstrap compatible HTML Back-End for Org - - rainbow-delimiters - Highlight brackets according to their depth - - rainbow-mode - Colorize color names in buffers - - smartparens - Automatic insertion, wrapping and paredit-like navigation with user defined pairs. - - swiper - Isearch with an overview. Oh, man! - - yasnippet - Yet another snippet extension for Emacs. - + A require for all my installed packages, so that they are automatically installed + in case I want to setup my emacs on another pc he same way as always #+BEGIN_SRC emacs-lisp (unless (package-installed-p 'use-package) (package-refresh-contents) @@ -46,9 +31,15 @@ Adding the melpa package repository to Emacs. (require 'use-package) (setq use-package-always-ensure t) -(use-package aggressive-indent) +;; (use-package aggressive-indent) is a dep (use-package anaconda-mode) -;; (use-package auctex) throws error with use-package +(use-package auctex +:defer t +:ensure t) +(use-package auto-complete) +(use-package auto-complete-auctex +:defer t +:ensure t) (use-package counsel) (use-package eclim) (use-package flycheck) @@ -60,10 +51,10 @@ Adding the melpa package repository to Emacs. (use-package rainbow-mode) (use-package smartparens) (use-package swiper) -(use-package yasnippet) +;; (use-package yasnippet) is a dep #+END_SRC * Themes -Using the [[https://github.com/cpaulik/emacs-material-theme][Material]]-Theme. + Using the [[https://github.com/cpaulik/emacs-material-theme][Material]]-Theme. #+BEGIN_SRC emacs-lisp (load-theme 'material t) #+END_SRC @@ -75,7 +66,7 @@ Changes the Emacs background to the terminals defaults. (Generally) (set-face-background 'default "unspecified-bg"))) #+END_SRC * Emacs behavior -Save auto-save files in ~/.emacs-save + Save auto-save files in ~/.emacs-save #+BEGIN_SRC emacs-lisp (f-mkdir "~/.emacs-saves") (setq auto-save-file-name-transforms @@ -83,7 +74,7 @@ Save auto-save files in ~/.emacs-save #+END_SRC * Functions -All the functions I use. + All the functions I use. ** Cut/Copy and Paste by Boruch Baum A nice way to copy and paste contents comfortably inside and out of emacs. *** Copy @@ -202,17 +193,25 @@ Use Evince as default pdf viewer. (add-to-list 'org-file-apps '("\\.pdf\\'" . "evince %s")))) #+END_SRC -Activate Syntax Highlighting in Org-mode. +Enable syntax highlighting in Org-mode. #+BEGIN_SRC emacs-lisp (add-hook 'org-mode-hook '(lambda () (setq org-src-fontify-natively t))) #+END_SRC +Enable automatic translation of special characters +#+BEGIN_SRC emacs-lisp +(add-hook 'org-mode-hook + '(lambda () + (setq org-pretty-entities t))) +#+END_SRC + Add rainbow-delimiters in org-mode #+BEGIN_SRC emacs-lisp (add-hook 'org-mode-hook 'rainbow-delimiters-mode) #+END_SRC + ** Ivy/Counsel/Swiper #+BEGIN_SRC emacs-lisp (counsel-mode 1) diff --git a/emacs/.emacs.d/init.el b/emacs/.emacs.d/init.el index d9df59e..3ced67f 100644 --- a/emacs/.emacs.d/init.el +++ b/emacs/.emacs.d/init.el @@ -5,6 +5,7 @@ ;; If you edit it by hand, you could mess it up, so be careful. ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. + '(org-agenda-files (quote ("~/Nextcloud/orgs/man.org"))) '(package-selected-packages (quote (auto-complete-auctex auto-complete counsel swiper material-theme anaconda-mode rainbow-mode ox-twbs google-this auctex smartparens eclim flycheck rainbow-delimiters forest-blue-theme)))) diff --git a/emacs/.emacs.d/recentf b/emacs/.emacs.d/recentf deleted file mode 100644 index c41188b..0000000 --- a/emacs/.emacs.d/recentf +++ /dev/null @@ -1,13 +0,0 @@ -;;; Automatically generated by ‘recentf’ on Sat Jan 13 17:16:00 2018. - -(setq recentf-list - '( - "/home/tuan/.dotfiles/emacs/.emacs.d/config.org" - )) - -(setq recentf-filter-changer-current 'nil) - - -;; Local Variables: -;; coding: utf-8-emacs -;; End: diff --git a/emacs/.emacs.d/snippets/latex-mode/section b/emacs/.emacs.d/snippets/latex-mode/section index 88faeab..aa2990e 100644 --- a/emacs/.emacs.d/snippets/latex-mode/section +++ b/emacs/.emacs.d/snippets/latex-mode/section @@ -3,6 +3,4 @@ # key: sec # -- \section{${1:name}} -\label{sec:${2:label}} - $0 \ No newline at end of file diff --git a/emacs/.emacs.d/snippets/latex-mode/subsec b/emacs/.emacs.d/snippets/latex-mode/subsec index 5658494..461c010 100644 --- a/emacs/.emacs.d/snippets/latex-mode/subsec +++ b/emacs/.emacs.d/snippets/latex-mode/subsec @@ -3,6 +3,4 @@ # key: sub # -- \subsection{${1:name}} -\label{subsec:${2:label}} - $0 \ No newline at end of file diff --git a/emacs/.emacs.d/snippets/latex-mode/template b/emacs/.emacs.d/snippets/latex-mode/template new file mode 100644 index 0000000..5fbd078 --- /dev/null +++ b/emacs/.emacs.d/snippets/latex-mode/template @@ -0,0 +1,16 @@ +# -*- mode: snippet -*- +# name: template +# key: template +# -- +\documentclass{article}[12pt] + +\usepackage{titling} +\usepackage[onehalfspacing]{setspace} +\usepackage[a4paper, left=2.5cm, right=2cm, top=2cm, bottom=2cm]{geometry} +\usepackage{hyperref} +\usepackage[ngerman]{babel} +\usepackage{datetime} +\pagenumbering{gobble} +\fontfamily{sans} + +$0 \ No newline at end of file diff --git a/emacs/.emacs.d/snippets/latex-mode/usepackage b/emacs/.emacs.d/snippets/latex-mode/usepackage new file mode 100644 index 0000000..ed620e2 --- /dev/null +++ b/emacs/.emacs.d/snippets/latex-mode/usepackage @@ -0,0 +1,7 @@ +# -*- mode: snippet -*- +# name: usepackage +# key: use +# -- +\usepackage{${1:name}} + +$0 \ No newline at end of file diff --git a/emacs/.emacs.d/snippets/org-mode/color b/emacs/.emacs.d/snippets/org-mode/color new file mode 100644 index 0000000..fcb3806 --- /dev/null +++ b/emacs/.emacs.d/snippets/org-mode/color @@ -0,0 +1,5 @@ +# -*- mode: snippet -*- +# name: color +# key: col +# -- +\color{$0} \ No newline at end of file diff --git a/emacs/.emacs.d/tramp b/emacs/.emacs.d/tramp deleted file mode 100644 index 44f980c..0000000 --- a/emacs/.emacs.d/tramp +++ /dev/null @@ -1,20 +0,0 @@ -;; -*- emacs-lisp -*- <18/01/15 17:18:27 /home/tuan/.emacs.d/tramp> -;; Tramp connection history. Don't change this file. -;; You can delete it, forcing Tramp to reapply the checks. - -((["ssh" "infra" "mx" nil nil] - ("uname" "Linux 4.4.0-109-generic") - ("locale" "LC_ALL=en_US.utf8") - ("test" "test") - ("remote-path" - ("/bin" "/usr/bin" "/sbin" "/usr/sbin" "/usr/local/bin" "/usr/local/sbin")) - ("remote-shell" "/bin/sh") - ("readlink" "\\readlink") - ("stat" nil) - ("perl-file-spec" t) - ("perl-cwd-realpath" t) - ("perl" "\\perl") - ("id" "/usr/bin/id") - ("gid-integer" 1000) - ("gid-string" "infra") - ("file-exists" "test -e"))) diff --git a/i3/.config/termite/config b/i3/.config/termite/config index 8460811..a37e944 100644 --- a/i3/.config/termite/config +++ b/i3/.config/termite/config @@ -3,7 +3,7 @@ #audible_bell = false #clickable_url = true #dynamic_title = true -font = Monospace 12 +font = Dejavu Sans Mono 12 #fullscreen = true #geometry = 640x480 #icon_name = terminal diff --git a/zsh/.zshrc b/zsh/.zshrc index d56fc4d..da714ed 100644 --- a/zsh/.zshrc +++ b/zsh/.zshrc @@ -66,5 +66,7 @@ alias -s tex=emacs alias -s cpp=emacs alias org="e ~/Nextcloud/orgs/man.org" alias neofetch="neofetch --block_range 0 16" +alias diff="diff -s" + source $ZSH/oh-my-zsh.sh export GPG_TTY=$(tty)