Merge branch 'master' into master

.gitignore

@@ -1,2 +1,5 @@
 __pycache__/
 .vscode
+*.iml
+.idea/codeStyles/Project.xml
+*.xml

.travis.yml

@@ -1,22 +1,17 @@
+sudo: false
 language: python
-cache:
+cache: pip
-  directories:
-    - __pycache__
 python:
-- "3.6"
+  - "3.6"
-before_install:
-- sudo pip install -r requirements.txt
-- pip install flake8
 script:
-- python scripts/lint.py
+  - python scripts/lint.py
-- python scripts/readme.py
+  - python scripts/readme.py
-- python scripts/tdd.py
+  - python scripts/tdd.py
-- python3 website/main.py
+  - python website/main.py
-- python3 scripts/auto-lint.py
+  - python scripts/auto-lint.py
 after_success:
-- sed -i -e 's/\r$//' .travis/push.sh
+  - sed -i -e 's/\r$//' .travis/push.sh
-- .travis/push.sh
+  - .travis/push.sh
-group: deprecated-2017Q4
 env:
   global:
-  - secure: RucoyHikFKD7yQq7FBHxOpwYSHSFYUO7QS/5VEXvU55AMnHwB97aI0DcQSMa+XHaSFVsqd4fR7nAP+5H6GMW/lUhIdeXIGzehgBTfuNeQmng2djGgS1lWY9fEOsn2XEL7JlXMi2P5YdZDpOAfiiLqT3W8EaCWDdV60tkizbSQhig2R3exI/649AjmGkIws+NqoYqrEfNpnTvgxJkp2jNuKfBkr0aaVdYuxdI6Kf2KnipEeuKsKJFds+tTjduEUKTg7I8lNSB+tQ9wIHNTDZffZrzODzE2esAZtnflxhkGQ6q7fW8DEj0rheuer+yD4WBWfph1CIxTL6B3VZgT6XQXCu09XzqgRUack0KIS6SBRKjRYJymH3eKNlxZGPpk4s90bX0Qo0a0vvcT4g/iejyVb917pcn2LjRZmmsFQUfJOcCJgU6EUvqNpfM9SWV8fJhaPOacvUnzDxFav3eRdDHaZYgXf0tzJfLAjsTv7rFbLZEnpqtvyKbHrXYLf9sICyPlHbCy4L5KAfguu735v0YPXko5Aabl6PvGcfafyLxVUb/0Y5ot3pLtGVJflfHeqYz8qbkoqp5RovSvTXntx/vVlx20TSE/rQP2l6JUNt98sGFJ+yOZ3SkMnyMdjE1YqeEngxZdzukec2SM3PtnaWxSbxV8Ue1XnM8D5nzhTf4UI8=
+    - secure: RucoyHikFKD7yQq7FBHxOpwYSHSFYUO7QS/5VEXvU55AMnHwB97aI0DcQSMa+XHaSFVsqd4fR7nAP+5H6GMW/lUhIdeXIGzehgBTfuNeQmng2djGgS1lWY9fEOsn2XEL7JlXMi2P5YdZDpOAfiiLqT3W8EaCWDdV60tkizbSQhig2R3exI/649AjmGkIws+NqoYqrEfNpnTvgxJkp2jNuKfBkr0aaVdYuxdI6Kf2KnipEeuKsKJFds+tTjduEUKTg7I8lNSB+tQ9wIHNTDZffZrzODzE2esAZtnflxhkGQ6q7fW8DEj0rheuer+yD4WBWfph1CIxTL6B3VZgT6XQXCu09XzqgRUack0KIS6SBRKjRYJymH3eKNlxZGPpk4s90bX0Qo0a0vvcT4g/iejyVb917pcn2LjRZmmsFQUfJOcCJgU6EUvqNpfM9SWV8fJhaPOacvUnzDxFav3eRdDHaZYgXf0tzJfLAjsTv7rFbLZEnpqtvyKbHrXYLf9sICyPlHbCy4L5KAfguu735v0YPXko5Aabl6PvGcfafyLxVUb/0Y5ot3pLtGVJflfHeqYz8qbkoqp5RovSvTXntx/vVlx20TSE/rQP2l6JUNt98sGFJ+yOZ3SkMnyMdjE1YqeEngxZdzukec2SM3PtnaWxSbxV8Ue1XnM8D5nzhTf4UI8=

CONTRIBUTING.md

@@ -8,7 +8,7 @@ Here's what you can do to help:
 - Be part of the discussion by helping out with [existing issues](https://github.com/kriadmin/30-seconds-of-python-code/issues) or talking on our [gitter channel](https://gitter.im/30-seconds-of-python-code/Lobby).
 - Submit [pull requests](https://github.com/kriadmin/30-seconds-of-python-code/pulls) with snippets you have created (see below for guidelines).
 - Fix typos in existing snippets, improve snippet descriptions and explanations or provide better examples.
-- Before submitting a PR for any new snippets go through [this](https://github.com/kriadmin/30-seconds-of-python-code/projects/1) project. If your snippet is not there, then go ahead and submit a PR. Else if it is in the done column, sorry it has been already implemented.If it is in any other column submit a PR and give the card's link in the description section of PR.
+- Before submitting a PR for any new snippets go through [this](https://github.com/kriadmin/30-seconds-of-python-code/projects/1) project. If your snippet is not there, then go ahead and submit a PR. Else if it is in the done column, sorry it has been already implemented. If it is in any other column submit a PR and give the card's link in the description section of PR.
 - **Working on your first Pull Request?** You can learn how from this *free* series [How to Contribute to an Open Source Project on GitHub](https://egghead.io/series/how-to-contribute-to-an-open-source-project-on-github)
 
 ### Snippet submission and Pull request guidelines
@@ -39,7 +39,7 @@ Here's what you can do to help:
 - You can start creating a new snippet, by using the [snippet template](snippet_template.md) to format your snippets.
 - Updating the README.md file should only be done by altering the scripts in the **scripts** folder or altering their relative static parts in the **static-parts** folder.
 - You may tag your snippet in tag_databse although it is _not_ necessary.
-- You may add your name as `[Name][@github_username]` to the contributor database. If the snippet already exists and you are making changes to it you can add your name at the laste seperated by a comma.
+- You may add your name as `[Name][@github_username]` to the contributor database. If the snippet already exists and you are making changes to it you can add your name at the last seperated by a comma.
 <!--
 ### Additional guidelines and conventions regarding snippets
 

README.md

@@ -742,7 +742,7 @@ byte_size('Hello World') # 11
 
 Capitalizes the first letter of a string.
 
-Capitalizes the fist letter of the sring and then adds it with rest of the string. Omit the `lower_rest` parameter to keep the rest of the string intact, or set it to `true` to convert to lowercase.
+Capitalizes the fist letter of the string and then adds it with rest of the string. Omit the `lower_rest` parameter to keep the rest of the string intact, or set it to `true` to convert to lowercase.
 ```py
 def capitalize(string, lower_rest=False):
     return string[:1].upper() + (string[1:].lower() if lower_rest else string[1:])

contributor_database

@@ -12,7 +12,7 @@ max_n:[Rohit Tanwar](@kriadmin)
 min_n:[Rohit Tanwar](@kriadmin)
 shuffle:[Rohit Tanwar](@kriadmin)
 spread:[Rohit Tanwar](@kriadmin)
-zip:[Rohit Tanwar](@kriadmin)
+zip:[Rohit Tanwar](@kriadmin),[Leonardo Galdino](@LeonardoGaldino)
 byte_size:[Rohit Tanwar](@kriadmin)
 capitalize:[Rohit Tanwar](@kriadmin)
 capitalize_every_word:[Rohit Tanwar](@kriadmin)
@@ -25,7 +25,8 @@ insertion_sort:[Meet Zaveri](@meetzaveri),[Rohit Tanwar](@kriadmin)
 difference_by:[Rohit Tanwar](@kriadmin)
 bubble_sort: [Shobhit Sachan](@sachans)
 has_duplicates: [Rob-Rychs](@Rob-Rychs)
-keys_only: [Rob-Rychs](@Rob-Rychs)
+keys_only: [Rob-Rychs](@Rob-Rychs),[Matteo Veraldi](@mattveraldi)
 values_only: [Rob-Rychs](@Rob-Rychs)
 all_unique: [Rob-Rychs](@Rob-Rychs)
 fibonacci_until_num: [Nian Lee](@scraggard)
+fermat_test: [Alexander Pozdniakov](@0awawa0)

requirements.txt

@@ -2,8 +2,8 @@ autopep8==1.3.3
 cffi==1.11.4
 click==6.7
 emoji==0.4.5
-flake8==3.5.0
+flake8==3.6.0
-Flask==0.12.2
+Flask==1.0
 Flask-OAuth==0.12
 gunicorn==19.7.1
 httplib2==0.10.3
@@ -14,4 +14,4 @@ misaka==2.1.0
 mistune==0.8.3
 oauth2==1.9.0.post1
 pycparser==2.18
-Werkzeug==0.14.1
+Werkzeug==0.14.1

snippets/byte_size.md

@@ -2,7 +2,7 @@
 
 Returns the length of a string in bytes.
 
-`utf-8` encodes a given string and find its length.
+`utf-8` encodes a given string, then `len` finds the length of the encoded string.
 
 ```python
 def byte_size(string):
@@ -12,4 +12,4 @@ def byte_size(string):
 ```python
 byte_size('😀') # 4
 byte_size('Hello World') # 11
-```
+```

snippets/capitalize.md

@@ -2,7 +2,7 @@
 
 Capitalizes the first letter of a string.
 
-Capitalizes the fist letter of the sring and then adds it with rest of the string. Omit the `lower_rest` parameter to keep the rest of the string intact, or set it to `true` to convert to lowercase.
+Capitalizes the first letter of the string and then adds it with rest of the string. Omit the `lower_rest` parameter to keep the rest of the string intact, or set it to `true` to convert to lowercase.
 
 ```python
 def capitalize(string, lower_rest=False):

snippets/capitalize_every_word.md

@@ -2,7 +2,7 @@
 
 Capitalizes the first letter of every word in a string.
 
-Uses `str.title` to capitalize first letter of evry word in the string.
+Uses `str.title` to capitalize first letter of every word in the string.
 
 ```python
 def capitalize_every_word(string):

snippets/count_occurences.md

@@ -2,7 +2,7 @@
 
 :information_source: Already implemented via `list.count()`.
 
-Counts the occurrences of a value in an list.
+Counts the occurrences of a value in a list.
 
 Uses the list comprehension to increment a counter each time you encounter the specific value inside the list.
 

snippets/count_vowels.md

@@ -7,12 +7,9 @@ Use a regular expression to count the number of vowels `(A, E, I, O, U)` in a st
 ```python
 import re
 
-
 def count_vowels(str):
-    return len(len(re.findall(r'[aeiou]', str, re.IGNORECASE)))
+    return len(re.findall(r'[aeiou]', str, re.IGNORECASE))
-```
 
-``` python
 count_vowels('foobar') # 3
-count_vowels('gym') # 0
+count_vowels('gym')# 0
 ```

snippets/decapitalize.md

@@ -2,7 +2,7 @@
 
 Decapitalizes the first letter of a string.
 
-Decapitalizes the fist letter of the sring and then adds it with rest of the string. Omit the `upper_rest` parameter to keep the rest of the string intact, or set it to `true` to convert to uppercase.
+Decapitalizes the first letter of the string and then adds it with rest of the string. Omit the `upper_rest` parameter to keep the rest of the string intact, or set it to `true` to convert to uppercase.
 
 ```python
 def decapitalize(string, upper_rest=False):

snippets/fermat_test.md

@@ -0,0 +1,33 @@
+### fermat_test
+
+Checks if the number is prime or not. Returns True if passed number is prime, and False if not.
+
+The function uses Fermat's theorem. 
+First, it picks the number `A` in range `1`..`(n-1)`, then it checks if `A` to the power of `n-1` modulo `n` equals `1`. 
+If not, the number is not prime, else it's pseudoprime with probability 1/2. Applying this test `k `times we have probability `1/(2^k)`.
+For example, if the number passes the test `10` times, we have probability `0.00098`.
+
+``` python
+from random import randint
+
+
+def fermat_test(n, k=100):
+    if n <= 1:
+        return False
+    for i in range(k):
+        a = randint(1, n - 1)
+        if pow(a, n - 1, n) != 1:
+            return False
+    return True
+
+```
+
+``` python
+fermat_test(0)  # False
+fermat_test(1)  # False
+fermat_test(561)  # False
+fermat_test(41041)  # False
+fermat_test(17)  # True
+fermat_test(162259276829213363391578010288127)  # True
+fermat_test(-1)  # False
+```

snippets/is_anagram.md

@@ -0,0 +1,20 @@
+### is_anagram
+
+Determine if 2 strings are anagrams.
+
+Returns true if 2 strings are anagrams of each other, false otherwise.
+Capital letters and whitespaces are ignored.
+
+``` python
+def is_anagram(str1, str2):
+    str1, str2 = str1.replace(" ", ""), str2.replace(" ", "")
+
+    if len(str1) != len(str2):
+        return False
+    else:
+        return sorted(str1.lower()) == sorted(str2.lower())
+```
+
+``` python
+is_anagram("anagram", "Nag a ram")  # True
+```

snippets/is_upper_case.md

@@ -11,6 +11,6 @@ def is_upper_case(string):
 
 ```python
 is_upper_case('ABC') # True
-is_upper_case('a3@$') # True
+is_upper_case('a3@$') # False
 is_upper_case('aB4') # False
-```
+```

snippets/keys_only.md

@@ -2,14 +2,11 @@
 
 Function which accepts a dictionary of key value pairs and returns a new flat list of only the keys.
 
-Uses the .items() function with a for loop on the dictionary to track both the key and value and returns a new list by appending the keys to it. Best used on 1 level-deep key:value pair dictionaries (a flat dictionary) and not nested data-structures which are also commonly used with dictionaries. (a flat dictionary resembles a json and a flat list an array for javascript people).
+Uses the .keys() method of "dict" objects. dict.keys() returns a view object that displays a list of all the keys. Then, list(dict.keys()) returns a list that stores all the keys of a dict.
 
 ``` python
 def keys_only(flat_dict):
-    lst = []
+    return list(flat_dict.keys())
-    for k, v in flat_dict.items():
-        lst.append(k)
-    return lst
 ```
 
 ``` python

snippets/zip.md

@@ -12,7 +12,7 @@ def zip(*args, fillvalue=None):
     result = []
     for i in range(max_length):
         result.append([
-            args[k][i] if i < len(args[k]) else None for k in range(len(args))
+            args[k][i] if i < len(args[k]) else fillvalue for k in range(len(args))
         ])
     return result
 ```

test/keys_only/keys_only.py

@@ -1,5 +1,2 @@
 def keys_only(flat_dict):
-    lst = []
+    return list(flat_dict.keys())
-    for k, v in flat_dict.items():
-        lst.append(k)
-    return lst

website/requirements.txt

@@ -2,7 +2,7 @@ cffi==1.11.4
 click==6.7
 emoji==0.4.5
 flake8==3.5.0
-Flask==0.12.2
+Flask==1.0
 Flask-OAuth==0.12
 gunicorn==19.7.1
 httplib2==0.10.3

website/web/Lib/site-packages/Flask-0.12.2.dist-info/DESCRIPTION.rst

@@ -1,46 +0,0 @@
-Flask
------
-
-Flask is a microframework for Python based on Werkzeug, Jinja 2 and good
-intentions. And before you ask: It's BSD licensed!
-
-Flask is Fun
-````````````
-
-Save in a hello.py:
-
-.. code:: python
-
-    from flask import Flask
-    app = Flask(__name__)
-
-    @app.route("/")
-    def hello():
-        return "Hello World!"
-
-    if __name__ == "__main__":
-        app.run()
-
-And Easy to Setup
-`````````````````
-
-And run it:
-
-.. code:: bash
-
-    $ pip install Flask
-    $ python hello.py
-     * Running on http://localhost:5000/
-
- Ready for production? `Read this first <http://flask.pocoo.org/docs/deploying/>`.
-
-Links
-`````
-
-* `website <http://flask.pocoo.org/>`_
-* `documentation <http://flask.pocoo.org/docs/>`_
-* `development version
-  <http://github.com/pallets/flask/zipball/master#egg=Flask-dev>`_
-
-
-

website/web/Lib/site-packages/Flask-0.12.2.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

website/web/Lib/site-packages/Flask-0.12.2.dist-info/LICENSE.txt

@@ -1,33 +0,0 @@
-Copyright (c) 2015 by Armin Ronacher and contributors.  See AUTHORS
-for more details.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms of the software as well
-as documentation, with or without modification, are permitted provided
-that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following
-  disclaimer in the documentation and/or other materials provided
-  with the distribution.
-
-* The names of the contributors may not be used to endorse or
-  promote products derived from this software without specific
-  prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT
-NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
-OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGE.

website/web/Lib/site-packages/Flask-0.12.2.dist-info/METADATA

@@ -1,75 +0,0 @@
-Metadata-Version: 2.0
-Name: Flask
-Version: 0.12.2
-Summary: A microframework based on Werkzeug, Jinja2 and good intentions
-Home-page: http://github.com/pallets/flask/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Platform: any
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-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 :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: Jinja2 (>=2.4)
-Requires-Dist: Werkzeug (>=0.7)
-Requires-Dist: click (>=2.0)
-Requires-Dist: itsdangerous (>=0.21)
-
-Flask
------
-
-Flask is a microframework for Python based on Werkzeug, Jinja 2 and good
-intentions. And before you ask: It's BSD licensed!
-
-Flask is Fun
-````````````
-
-Save in a hello.py:
-
-.. code:: python
-
-    from flask import Flask
-    app = Flask(__name__)
-
-    @app.route("/")
-    def hello():
-        return "Hello World!"
-
-    if __name__ == "__main__":
-        app.run()
-
-And Easy to Setup
-`````````````````
-
-And run it:
-
-.. code:: bash
-
-    $ pip install Flask
-    $ python hello.py
-     * Running on http://localhost:5000/
-
- Ready for production? `Read this first <http://flask.pocoo.org/docs/deploying/>`.
-
-Links
-`````
-
-* `website <http://flask.pocoo.org/>`_
-* `documentation <http://flask.pocoo.org/docs/>`_
-* `development version
-  <http://github.com/pallets/flask/zipball/master#egg=Flask-dev>`_
-
-
-

website/web/Lib/site-packages/Flask-0.12.2.dist-info/RECORD

@@ -1,52 +0,0 @@
-Flask-0.12.2.dist-info/DESCRIPTION.rst,sha256=DmJm8IBlBjl3wkm0Ly23jYvWbvK_mCuE5oUseYCijbI,810
-Flask-0.12.2.dist-info/LICENSE.txt,sha256=hLgKluMRHSnxG-L0EmrqjmKgG5cHlff6pIh3rCNINeI,1582
-Flask-0.12.2.dist-info/METADATA,sha256=OgSkJQ_kmrz4qEkS-OzYtL75uZmXAThymkOcGR4kXRQ,1948
-Flask-0.12.2.dist-info/RECORD,,
-Flask-0.12.2.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110
-Flask-0.12.2.dist-info/entry_points.txt,sha256=jzk2Wy2h30uEcqqzd4CVnlzsMXB-vaD5GXjuPMXmTmI,60
-Flask-0.12.2.dist-info/metadata.json,sha256=By8kZ1vY9lLEAGnRiWNBhudqKvLPo0HkZVXTYECyPKk,1389
-Flask-0.12.2.dist-info/top_level.txt,sha256=dvi65F6AeGWVU0TBpYiC04yM60-FX1gJFkK31IKQr5c,6
-flask/__init__.py,sha256=sHdK1v6WRbVmCN0fEv990EE7rOT2UlamQkSof2d0Dt0,1673
-flask/__main__.py,sha256=cldbNi5zpjE68XzIWI8uYHNWwBHHVJmwtlXWk6P4CO4,291
-flask/_compat.py,sha256=VlfjUuLjufsTHJIjr_ZsnnOesSbAXIslBBgRe5tfOok,2802
-flask/app.py,sha256=6DPjtb5jUJWgL5fXksG5boA49EB3l-k9pWyftitbNNk,83169
-flask/blueprints.py,sha256=6HVasMcPcaq7tk36kCrgX4bnhTkky4G5WIWCyyJL8HY,16872
-flask/cli.py,sha256=2NXEdCOu5-4ymklxX4Lf6bjb-89I4VHYeP6xScR3i8E,18328
-flask/config.py,sha256=Ym5Jenyu6zAZ1fdVLeKekY9-EsKmq8183qnRgauwCMY,9905
-flask/ctx.py,sha256=UPA0YwoIlHP0txOGanC9lQLSGv6eCqV5Fmw2cVJRmgQ,14739
-flask/debughelpers.py,sha256=z-uQavKIymOZl0WQDLXsnacA00ERIlCx3S3Tnb_OYsE,6024
-flask/exthook.py,sha256=SvXs5jwpcOjogwJ7SNquiWTxowoN1-MHFoqAejWnk2o,5762
-flask/globals.py,sha256=I3m_4RssLhWW1R11zuEI8oFryHUHX3NQwjMkGXOZzg8,1645
-flask/helpers.py,sha256=KrsQ2Yo3lOVHvBTgQCLvpubgmTOpQdTTyiCOOYlwDuQ,38452
-flask/json.py,sha256=1zPM-NPLiWoOfGd0P14FxnEkeKtjtUZxMC9pyYyDBYI,9183
-flask/logging.py,sha256=UG-77jPkRClk9w1B-_ArjjXPuj9AmZz9mG0IRGvptW0,2751
-flask/sessions.py,sha256=QBKXVYKJ-HKbx9m6Yb5yan_EPq84a5yevVLgAzNKFQY,14394
-flask/signals.py,sha256=MfZk5qTRj_R_O3aGYlTEnx2g3SvlZncz8Ii73eKK59g,2209
-flask/templating.py,sha256=u7FbN6j56H_q6CrdJJyJ6gZtqaMa0vh1_GP12gEHRQQ,4912
-flask/testing.py,sha256=II8EO_NjOT1LvL8Hh_SdIFL_BdlwVPcB9yot5pbltxE,5630
-flask/views.py,sha256=6OPv7gwu3h14JhqpeeMRWwrxoGHsUr4_nOGSyTRAxAI,5630
-flask/wrappers.py,sha256=1S_5mmuA1Tlx7D9lXV6xMblrg-PdAauNWahe-henMEE,7612
-flask/ext/__init__.py,sha256=UEezCApsG4ZJWqwUnX9YmWcNN4OVENgph_9L05n0eOM,842
-../../Scripts/flask.exe,sha256=WiosIiBPkig5ooCR_yaHUrP5WMPviLDqJxogDFixmOY,98150
-Flask-0.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-flask/ext/__pycache__/__init__.cpython-36.pyc,,
-flask/__pycache__/app.cpython-36.pyc,,
-flask/__pycache__/blueprints.cpython-36.pyc,,
-flask/__pycache__/cli.cpython-36.pyc,,
-flask/__pycache__/config.cpython-36.pyc,,
-flask/__pycache__/ctx.cpython-36.pyc,,
-flask/__pycache__/debughelpers.cpython-36.pyc,,
-flask/__pycache__/exthook.cpython-36.pyc,,
-flask/__pycache__/globals.cpython-36.pyc,,
-flask/__pycache__/helpers.cpython-36.pyc,,
-flask/__pycache__/json.cpython-36.pyc,,
-flask/__pycache__/logging.cpython-36.pyc,,
-flask/__pycache__/sessions.cpython-36.pyc,,
-flask/__pycache__/signals.cpython-36.pyc,,
-flask/__pycache__/templating.cpython-36.pyc,,
-flask/__pycache__/testing.cpython-36.pyc,,
-flask/__pycache__/views.cpython-36.pyc,,
-flask/__pycache__/wrappers.cpython-36.pyc,,
-flask/__pycache__/_compat.cpython-36.pyc,,
-flask/__pycache__/__init__.cpython-36.pyc,,
-flask/__pycache__/__main__.cpython-36.pyc,,

website/web/Lib/site-packages/Flask-0.12.2.dist-info/WHEEL

@@ -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
-

website/web/Lib/site-packages/Flask-0.12.2.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-
-        [console_scripts]
-        flask=flask.cli:main
-    

website/web/Lib/site-packages/Flask-0.12.2.dist-info/metadata.json

@@ -1 +0,0 @@
-{"classifiers": ["Development Status :: 4 - Beta", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "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 :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules"], "extensions": {"python.commands": {"wrap_console": {"flask": "flask.cli:main"}}, "python.details": {"contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}, "project_urls": {"Home": "http://github.com/pallets/flask/"}}, "python.exports": {"console_scripts": {"flask": "flask.cli:main"}}}, "extras": [], "generator": "bdist_wheel (0.29.0)", "license": "BSD", "metadata_version": "2.0", "name": "Flask", "platform": "any", "run_requires": [{"requires": ["Jinja2 (>=2.4)", "Werkzeug (>=0.7)", "click (>=2.0)", "itsdangerous (>=0.21)"]}], "summary": "A microframework based on Werkzeug, Jinja2 and good intentions", "version": "0.12.2"}

website/web/Lib/site-packages/Flask-0.12.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-flask

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/PKG-INFO

@@ -1,30 +0,0 @@
-Metadata-Version: 1.1
-Name: Flask-OAuth
-Version: 0.12
-Summary: Adds OAuth support to Flask
-Home-page: http://github.com/mitsuhiko/flask-oauth
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description: 
-        Flask-OAuth
-        -----------
-        
-        Adds OAuth support to Flask.
-        
-        Links
-        `````
-        
-        * `documentation <http://packages.python.org/Flask-OAuth>`_
-        * `development version
-          <http://github.com/mitsuhiko/flask-oauth/zipball/master#egg=Flask-OAuth-dev>`_
-        
-Platform: any
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/SOURCES.txt

@@ -1,10 +0,0 @@
-README
-flask_oauth.py
-setup.cfg
-setup.py
-Flask_OAuth.egg-info/PKG-INFO
-Flask_OAuth.egg-info/SOURCES.txt
-Flask_OAuth.egg-info/dependency_links.txt
-Flask_OAuth.egg-info/not-zip-safe
-Flask_OAuth.egg-info/requires.txt
-Flask_OAuth.egg-info/top_level.txt

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/installed-files.txt

@@ -1,8 +0,0 @@
-..\flask_oauth.py
-..\__pycache__\flask_oauth.cpython-36.pyc
-dependency_links.txt
-not-zip-safe
-PKG-INFO
-requires.txt
-SOURCES.txt
-top_level.txt

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/requires.txt

@@ -1,2 +0,0 @@
-Flask
-oauth2

website/web/Lib/site-packages/Flask_OAuth-0.12-py3.6.egg-info/top_level.txt

@@ -1 +0,0 @@
-flask_oauth

website/web/Lib/site-packages/Jinja2-2.10.dist-info/DESCRIPTION.rst

@@ -1,37 +0,0 @@
-
-Jinja2
-~~~~~~
-
-Jinja2 is a template engine written in pure Python.  It provides a
-`Django`_ inspired non-XML syntax but supports inline expressions and
-an optional `sandboxed`_ environment.
-
-Nutshell
---------
-
-Here a small example of a Jinja template::
-
-    {% extends 'base.html' %}
-    {% block title %}Memberlist{% endblock %}
-    {% block content %}
-      <ul>
-      {% for user in users %}
-        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
-      {% endfor %}
-      </ul>
-    {% endblock %}
-
-Philosophy
-----------
-
-Application logic is for the controller but don't try to make the life
-for the template designer too hard by giving him too few functionality.
-
-For more informations visit the new `Jinja2 webpage`_ and `documentation`_.
-
-.. _sandboxed: https://en.wikipedia.org/wiki/Sandbox_(computer_security)
-.. _Django: https://www.djangoproject.com/
-.. _Jinja2 webpage: http://jinja.pocoo.org/
-.. _documentation: http://jinja.pocoo.org/2/documentation/
-
-

website/web/Lib/site-packages/Jinja2-2.10.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

website/web/Lib/site-packages/Jinja2-2.10.dist-info/LICENSE.txt

@@ -1,31 +0,0 @@
-Copyright (c) 2009 by the Jinja Team, see AUTHORS for more details.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-    * The names of the contributors may not be used to endorse or
-      promote products derived from this software without specific
-      prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

website/web/Lib/site-packages/Jinja2-2.10.dist-info/METADATA

@@ -1,68 +0,0 @@
-Metadata-Version: 2.0
-Name: Jinja2
-Version: 2.10
-Summary: A small but fast and easy to use stand-alone template engine written in pure python.
-Home-page: http://jinja.pocoo.org/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description-Content-Type: UNKNOWN
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-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: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup :: HTML
-Requires-Dist: MarkupSafe (>=0.23)
-Provides-Extra: i18n
-Requires-Dist: Babel (>=0.8); extra == 'i18n'
-
-
-Jinja2
-~~~~~~
-
-Jinja2 is a template engine written in pure Python.  It provides a
-`Django`_ inspired non-XML syntax but supports inline expressions and
-an optional `sandboxed`_ environment.
-
-Nutshell
---------
-
-Here a small example of a Jinja template::
-
-    {% extends 'base.html' %}
-    {% block title %}Memberlist{% endblock %}
-    {% block content %}
-      <ul>
-      {% for user in users %}
-        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
-      {% endfor %}
-      </ul>
-    {% endblock %}
-
-Philosophy
-----------
-
-Application logic is for the controller but don't try to make the life
-for the template designer too hard by giving him too few functionality.
-
-For more informations visit the new `Jinja2 webpage`_ and `documentation`_.
-
-.. _sandboxed: https://en.wikipedia.org/wiki/Sandbox_(computer_security)
-.. _Django: https://www.djangoproject.com/
-.. _Jinja2 webpage: http://jinja.pocoo.org/
-.. _documentation: http://jinja.pocoo.org/2/documentation/
-
-

website/web/Lib/site-packages/Jinja2-2.10.dist-info/RECORD

@@ -1,63 +0,0 @@
-Jinja2-2.10.dist-info/DESCRIPTION.rst,sha256=b5ckFDoM7vVtz_mAsJD4OPteFKCqE7beu353g4COoYI,978
-Jinja2-2.10.dist-info/LICENSE.txt,sha256=JvzUNv3Io51EiWrAPm8d_SXjhJnEjyDYvB3Tvwqqils,1554
-Jinja2-2.10.dist-info/METADATA,sha256=18EgU8zR6-av-0-5y_gXebzK4GnBB_76lALUsl-6QHM,2258
-Jinja2-2.10.dist-info/RECORD,,
-Jinja2-2.10.dist-info/WHEEL,sha256=kdsN-5OJAZIiHN-iO4Rhl82KyS0bDWf4uBwMbkNafr8,110
-Jinja2-2.10.dist-info/entry_points.txt,sha256=NdzVcOrqyNyKDxD09aERj__3bFx2paZhizFDsKmVhiA,72
-Jinja2-2.10.dist-info/metadata.json,sha256=NPUJ9TMBxVQAv_kTJzvU8HwmP-4XZvbK9mz6_4YUVl4,1473
-Jinja2-2.10.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
-jinja2/__init__.py,sha256=xJHjaMoy51_KXn1wf0cysH6tUUifUxZCwSOfcJGEYZw,2614
-jinja2/_compat.py,sha256=xP60CE5Qr8FTYcDE1f54tbZLKGvMwYml4-8T7Q4KG9k,2596
-jinja2/_identifier.py,sha256=W1QBSY-iJsyt6oR_nKSuNNCzV95vLIOYgUNPUI1d5gU,1726
-jinja2/asyncfilters.py,sha256=cTDPvrS8Hp_IkwsZ1m9af_lr5nHysw7uTa5gV0NmZVE,4144
-jinja2/asyncsupport.py,sha256=UErQ3YlTLaSjFb94P4MVn08-aVD9jJxty2JVfMRb-1M,7878
-jinja2/bccache.py,sha256=nQldx0ZRYANMyfvOihRoYFKSlUdd5vJkS7BjxNwlOZM,12794
-jinja2/compiler.py,sha256=BqC5U6JxObSRhblyT_a6Tp5GtEU5z3US1a4jLQaxxgo,65386
-jinja2/constants.py,sha256=uwwV8ZUhHhacAuz5PTwckfsbqBaqM7aKfyJL7kGX5YQ,1626
-jinja2/debug.py,sha256=WTVeUFGUa4v6ReCsYv-iVPa3pkNB75OinJt3PfxNdXs,12045
-jinja2/defaults.py,sha256=Em-95hmsJxIenDCZFB1YSvf9CNhe9rBmytN3yUrBcWA,1400
-jinja2/environment.py,sha256=VnkAkqw8JbjZct4tAyHlpBrka2vqB-Z58RAP-32P1ZY,50849
-jinja2/exceptions.py,sha256=_Rj-NVi98Q6AiEjYQOsP8dEIdu5AlmRHzcSNOPdWix4,4428
-jinja2/ext.py,sha256=atMQydEC86tN1zUsdQiHw5L5cF62nDbqGue25Yiu3N4,24500
-jinja2/filters.py,sha256=yOAJk0MsH-_gEC0i0U6NweVQhbtYaC-uE8xswHFLF4w,36528
-jinja2/idtracking.py,sha256=2GbDSzIvGArEBGLkovLkqEfmYxmWsEf8c3QZwM4uNsw,9197
-jinja2/lexer.py,sha256=ySEPoXd1g7wRjsuw23uimS6nkGN5aqrYwcOKxCaVMBQ,28559
-jinja2/loaders.py,sha256=xiTuURKAEObyym0nU8PCIXu_Qp8fn0AJ5oIADUUm-5Q,17382
-jinja2/meta.py,sha256=fmKHxkmZYAOm9QyWWy8EMd6eefAIh234rkBMW2X4ZR8,4340
-jinja2/nativetypes.py,sha256=_sJhS8f-8Q0QMIC0dm1YEdLyxEyoO-kch8qOL5xUDfE,7308
-jinja2/nodes.py,sha256=L10L_nQDfubLhO3XjpF9qz46FSh2clL-3e49ogVlMmA,30853
-jinja2/optimizer.py,sha256=MsdlFACJ0FRdPtjmCAdt7JQ9SGrXFaDNUaslsWQaG3M,1722
-jinja2/parser.py,sha256=lPzTEbcpTRBLw8ii6OYyExHeAhaZLMA05Hpv4ll3ULk,35875
-jinja2/runtime.py,sha256=DHdD38Pq8gj7uWQC5usJyWFoNWL317A9AvXOW_CLB34,27755
-jinja2/sandbox.py,sha256=TVyZHlNqqTzsv9fv2NvJNmSdWRHTguhyMHdxjWms32U,16708
-jinja2/tests.py,sha256=iJQLwbapZr-EKquTG_fVOVdwHUUKf3SX9eNkjQDF8oU,4237
-jinja2/utils.py,sha256=q24VupGZotQ-uOyrJxCaXtDWhZC1RgsQG7kcdmjck2Q,20629
-jinja2/visitor.py,sha256=JD1H1cANA29JcntFfN5fPyqQxB4bI4wC00BzZa-XHks,3316
-Jinja2-2.10.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-jinja2/__pycache__/asyncfilters.cpython-36.pyc,,
-jinja2/__pycache__/asyncsupport.cpython-36.pyc,,
-jinja2/__pycache__/bccache.cpython-36.pyc,,
-jinja2/__pycache__/compiler.cpython-36.pyc,,
-jinja2/__pycache__/constants.cpython-36.pyc,,
-jinja2/__pycache__/debug.cpython-36.pyc,,
-jinja2/__pycache__/defaults.cpython-36.pyc,,
-jinja2/__pycache__/environment.cpython-36.pyc,,
-jinja2/__pycache__/exceptions.cpython-36.pyc,,
-jinja2/__pycache__/ext.cpython-36.pyc,,
-jinja2/__pycache__/filters.cpython-36.pyc,,
-jinja2/__pycache__/idtracking.cpython-36.pyc,,
-jinja2/__pycache__/lexer.cpython-36.pyc,,
-jinja2/__pycache__/loaders.cpython-36.pyc,,
-jinja2/__pycache__/meta.cpython-36.pyc,,
-jinja2/__pycache__/nativetypes.cpython-36.pyc,,
-jinja2/__pycache__/nodes.cpython-36.pyc,,
-jinja2/__pycache__/optimizer.cpython-36.pyc,,
-jinja2/__pycache__/parser.cpython-36.pyc,,
-jinja2/__pycache__/runtime.cpython-36.pyc,,
-jinja2/__pycache__/sandbox.cpython-36.pyc,,
-jinja2/__pycache__/tests.cpython-36.pyc,,
-jinja2/__pycache__/utils.cpython-36.pyc,,
-jinja2/__pycache__/visitor.cpython-36.pyc,,
-jinja2/__pycache__/_compat.cpython-36.pyc,,
-jinja2/__pycache__/_identifier.cpython-36.pyc,,
-jinja2/__pycache__/__init__.cpython-36.pyc,,

website/web/Lib/site-packages/Jinja2-2.10.dist-info/WHEEL

@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.30.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-

website/web/Lib/site-packages/Jinja2-2.10.dist-info/entry_points.txt

@@ -1,4 +0,0 @@
-
-    [babel.extractors]
-    jinja2 = jinja2.ext:babel_extract[i18n]
-    

website/web/Lib/site-packages/Jinja2-2.10.dist-info/metadata.json

@@ -1 +0,0 @@
-{"classifiers": ["Development Status :: 5 - Production/Stable", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "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", "Topic :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules", "Topic :: Text Processing :: Markup :: HTML"], "description_content_type": "UNKNOWN", "extensions": {"python.details": {"contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}, "project_urls": {"Home": "http://jinja.pocoo.org/"}}, "python.exports": {"babel.extractors": {"jinja2": "jinja2.ext:babel_extract [i18n]"}}}, "extras": ["i18n"], "generator": "bdist_wheel (0.30.0)", "license": "BSD", "metadata_version": "2.0", "name": "Jinja2", "run_requires": [{"extra": "i18n", "requires": ["Babel (>=0.8)"]}, {"requires": ["MarkupSafe (>=0.23)"]}], "summary": "A small but fast and easy to use stand-alone template engine written in pure python.", "version": "2.10"}

website/web/Lib/site-packages/Jinja2-2.10.dist-info/top_level.txt

@@ -1 +0,0 @@
-jinja2

website/web/Lib/site-packages/MarkupSafe-1.0-py3.6.egg-info/PKG-INFO

@@ -1,133 +0,0 @@
-Metadata-Version: 1.1
-Name: MarkupSafe
-Version: 1.0
-Summary: Implements a XML/HTML/XHTML Markup safe string for Python
-Home-page: http://github.com/pallets/markupsafe
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description: MarkupSafe
-        ==========
-        
-        Implements a unicode subclass that supports HTML strings:
-        
-        .. code-block:: python
-        
-            >>> from markupsafe import Markup, escape
-            >>> escape("<script>alert(document.cookie);</script>")
-            Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
-            >>> tmpl = Markup("<em>%s</em>")
-            >>> tmpl % "Peter > Lustig"
-            Markup(u'<em>Peter &gt; Lustig</em>')
-        
-        If you want to make an object unicode that is not yet unicode
-        but don't want to lose the taint information, you can use the
-        ``soft_unicode`` function.  (On Python 3 you can also use ``soft_str`` which
-        is a different name for the same function).
-        
-        .. code-block:: python
-        
-            >>> from markupsafe import soft_unicode
-            >>> soft_unicode(42)
-            u'42'
-            >>> soft_unicode(Markup('foo'))
-            Markup(u'foo')
-        
-        HTML Representations
-        --------------------
-        
-        Objects can customize their HTML markup equivalent by overriding
-        the ``__html__`` function:
-        
-        .. code-block:: python
-        
-            >>> class Foo(object):
-            ...  def __html__(self):
-            ...   return '<strong>Nice</strong>'
-            ...
-            >>> escape(Foo())
-            Markup(u'<strong>Nice</strong>')
-            >>> Markup(Foo())
-            Markup(u'<strong>Nice</strong>')
-        
-        Silent Escapes
-        --------------
-        
-        Since MarkupSafe 0.10 there is now also a separate escape function
-        called ``escape_silent`` that returns an empty string for ``None`` for
-        consistency with other systems that return empty strings for ``None``
-        when escaping (for instance Pylons' webhelpers).
-        
-        If you also want to use this for the escape method of the Markup
-        object, you can create your own subclass that does that:
-        
-        .. code-block:: python
-        
-            from markupsafe import Markup, escape_silent as escape
-        
-            class SilentMarkup(Markup):
-                __slots__ = ()
-        
-                @classmethod
-                def escape(cls, s):
-                    return cls(escape(s))
-        
-        New-Style String Formatting
-        ---------------------------
-        
-        Starting with MarkupSafe 0.21 new style string formats from Python 2.6 and
-        3.x are now fully supported.  Previously the escape behavior of those
-        functions was spotty at best.  The new implementations operates under the
-        following algorithm:
-        
-        1.  if an object has an ``__html_format__`` method it is called as
-            replacement for ``__format__`` with the format specifier.  It either
-            has to return a string or markup object.
-        2.  if an object has an ``__html__`` method it is called.
-        3.  otherwise the default format system of Python kicks in and the result
-            is HTML escaped.
-        
-        Here is how you can implement your own formatting:
-        
-        .. code-block:: python
-        
-            class User(object):
-        
-                def __init__(self, id, username):
-                    self.id = id
-                    self.username = username
-        
-                def __html_format__(self, format_spec):
-                    if format_spec == 'link':
-                        return Markup('<a href="/user/{0}">{1}</a>').format(
-                            self.id,
-                            self.__html__(),
-                        )
-                    elif format_spec:
-                        raise ValueError('Invalid format spec')
-                    return self.__html__()
-        
-                def __html__(self):
-                    return Markup('<span class=user>{0}</span>').format(self.username)
-        
-        And to format that user:
-        
-        .. code-block:: python
-        
-            >>> user = User(1, 'foo')
-            >>> Markup('<p>User: {0:link}').format(user)
-            Markup(u'<p>User: <a href="/user/1"><span class=user>foo</span></a>')
-        
-        Markupsafe supports Python 2.6, 2.7 and Python 3.3 and higher.
-        
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup :: HTML

website/web/Lib/site-packages/MarkupSafe-1.0-py3.6.egg-info/SOURCES.txt

@@ -1,18 +0,0 @@
-AUTHORS
-CHANGES
-LICENSE
-MANIFEST.in
-README.rst
-setup.cfg
-setup.py
-tests.py
-MarkupSafe.egg-info/PKG-INFO
-MarkupSafe.egg-info/SOURCES.txt
-MarkupSafe.egg-info/dependency_links.txt
-MarkupSafe.egg-info/not-zip-safe
-MarkupSafe.egg-info/top_level.txt
-markupsafe/__init__.py
-markupsafe/_compat.py
-markupsafe/_constants.py
-markupsafe/_native.py
-markupsafe/_speedups.c

website/web/Lib/site-packages/MarkupSafe-1.0-py3.6.egg-info/dependency_links.txt

@@ -1 +0,0 @@
-

website/web/Lib/site-packages/MarkupSafe-1.0-py3.6.egg-info/installed-files.txt

@@ -1,15 +0,0 @@
-..\markupsafe\_compat.py
-..\markupsafe\_constants.py
-..\markupsafe\_native.py
-..\markupsafe\__init__.py
-..\markupsafe\_speedups.c
-..\markupsafe\__pycache__\_compat.cpython-36.pyc
-..\markupsafe\__pycache__\_constants.cpython-36.pyc
-..\markupsafe\__pycache__\_native.cpython-36.pyc
-..\markupsafe\__pycache__\__init__.cpython-36.pyc
-..\markupsafe\_speedups.cp36-win_amd64.pyd
-dependency_links.txt
-not-zip-safe
-PKG-INFO
-SOURCES.txt
-top_level.txt

website/web/Lib/site-packages/MarkupSafe-1.0-py3.6.egg-info/not-zip-safe

@@ -1 +0,0 @@
-

website/web/Lib/site-packages/MarkupSafe-1.0-py3.6.egg-info/top_level.txt

@@ -1 +0,0 @@
-markupsafe

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/DESCRIPTION.rst

@@ -1,80 +0,0 @@
-Werkzeug
-========
-
-Werkzeug is a comprehensive `WSGI`_ web application library. It began as
-a simple collection of various utilities for WSGI applications and has
-become one of the most advanced WSGI utility libraries.
-
-It includes:
-
-* An interactive debugger that allows inspecting stack traces and source
-  code in the browser with an interactive interpreter for any frame in
-  the stack.
-* A full-featured request object with objects to interact with headers,
-  query args, form data, files, and cookies.
-* A response object that can wrap other WSGI applications and handle
-  streaming data.
-* A routing system for matching URLs to endpoints and generating URLs
-  for endpoints, with an extensible system for capturing variables from
-  URLs.
-* HTTP utilities to handle entity tags, cache control, dates, user
-  agents, cookies, files, and more.
-* A threaded WSGI server for use while developing applications locally.
-* A test client for simulating HTTP requests during testing without
-  requiring running a server.
-
-Werkzeug is Unicode aware and doesn't enforce any dependencies. It is up
-to the developer to choose a template engine, database adapter, and even
-how to handle requests. It can be used to build all sorts of end user
-applications such as blogs, wikis, or bulletin boards.
-
-`Flask`_ wraps Werkzeug, using it to handle the details of WSGI while
-providing more structure and patterns for defining powerful
-applications.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Werkzeug
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from werkzeug.wrappers import Request, Response
-
-    @Request.application
-    def application(request):
-        return Response('Hello, World!')
-
-    if __name__ == '__main__':
-        from werkzeug.serving import run_simple
-        run_simple('localhost', 4000, application)
-
-
-Links
------
-
-* Website: https://www.palletsprojects.com/p/werkzeug/
-* Releases: https://pypi.org/project/Werkzeug/
-* Code: https://github.com/pallets/werkzeug
-* Issue tracker: https://github.com/pallets/werkzeug/issues
-* Test status:
-
-  * Linux, Mac: https://travis-ci.org/pallets/werkzeug
-  * Windows: https://ci.appveyor.com/project/davidism/werkzeug
-
-* Test coverage: https://codecov.io/gh/pallets/werkzeug
-
-.. _WSGI: https://wsgi.readthedocs.io/en/latest/
-.. _Flask: https://www.palletsprojects.com/p/flask/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/LICENSE.txt

@@ -1,31 +0,0 @@
-Copyright © 2007 by the Pallets team.
-
-Some rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-* Redistributions of source code must retain the above copyright notice,
-  this list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright
-  notice, this list of conditions and the following disclaimer in the
-  documentation and/or other materials provided with the distribution.
-
-* Neither the name of the copyright holder nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-THIS SOFTWARE AND DOCUMENTATION IS PROVIDED BY THE COPYRIGHT HOLDERS AND
-CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,
-BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE AND DOCUMENTATION, EVEN IF ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGE.

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/METADATA

@@ -1,116 +0,0 @@
-Metadata-Version: 2.0
-Name: Werkzeug
-Version: 0.14.1
-Summary: The comprehensive WSGI web application library.
-Home-page: https://www.palletsprojects.org/p/werkzeug/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: BSD
-Description-Content-Type: UNKNOWN
-Platform: any
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-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: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Provides-Extra: dev
-Requires-Dist: coverage; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: sphinx; extra == 'dev'
-Requires-Dist: tox; extra == 'dev'
-Provides-Extra: termcolor
-Requires-Dist: termcolor; extra == 'termcolor'
-Provides-Extra: watchdog
-Requires-Dist: watchdog; extra == 'watchdog'
-
-Werkzeug
-========
-
-Werkzeug is a comprehensive `WSGI`_ web application library. It began as
-a simple collection of various utilities for WSGI applications and has
-become one of the most advanced WSGI utility libraries.
-
-It includes:
-
-* An interactive debugger that allows inspecting stack traces and source
-  code in the browser with an interactive interpreter for any frame in
-  the stack.
-* A full-featured request object with objects to interact with headers,
-  query args, form data, files, and cookies.
-* A response object that can wrap other WSGI applications and handle
-  streaming data.
-* A routing system for matching URLs to endpoints and generating URLs
-  for endpoints, with an extensible system for capturing variables from
-  URLs.
-* HTTP utilities to handle entity tags, cache control, dates, user
-  agents, cookies, files, and more.
-* A threaded WSGI server for use while developing applications locally.
-* A test client for simulating HTTP requests during testing without
-  requiring running a server.
-
-Werkzeug is Unicode aware and doesn't enforce any dependencies. It is up
-to the developer to choose a template engine, database adapter, and even
-how to handle requests. It can be used to build all sorts of end user
-applications such as blogs, wikis, or bulletin boards.
-
-`Flask`_ wraps Werkzeug, using it to handle the details of WSGI while
-providing more structure and patterns for defining powerful
-applications.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Werkzeug
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from werkzeug.wrappers import Request, Response
-
-    @Request.application
-    def application(request):
-        return Response('Hello, World!')
-
-    if __name__ == '__main__':
-        from werkzeug.serving import run_simple
-        run_simple('localhost', 4000, application)
-
-
-Links
------
-
-* Website: https://www.palletsprojects.com/p/werkzeug/
-* Releases: https://pypi.org/project/Werkzeug/
-* Code: https://github.com/pallets/werkzeug
-* Issue tracker: https://github.com/pallets/werkzeug/issues
-* Test status:
-
-  * Linux, Mac: https://travis-ci.org/pallets/werkzeug
-  * Windows: https://ci.appveyor.com/project/davidism/werkzeug
-
-* Test coverage: https://codecov.io/gh/pallets/werkzeug
-
-.. _WSGI: https://wsgi.readthedocs.io/en/latest/
-.. _Flask: https://www.palletsprojects.com/p/flask/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/RECORD

@@ -1,97 +0,0 @@
-Werkzeug-0.14.1.dist-info/DESCRIPTION.rst,sha256=rOCN36jwsWtWsTpqPG96z7FMilB5qI1CIARSKRuUmz8,2452
-Werkzeug-0.14.1.dist-info/LICENSE.txt,sha256=xndz_dD4m269AF9l_Xbl5V3tM1N3C1LoZC2PEPxWO-8,1534
-Werkzeug-0.14.1.dist-info/METADATA,sha256=FbfadrPdJNUWAxMOKxGUtHe5R3IDSBKYYmAz3FvI3uY,3872
-Werkzeug-0.14.1.dist-info/RECORD,,
-Werkzeug-0.14.1.dist-info/WHEEL,sha256=GrqQvamwgBV4nLoJe0vhYRSWzWsx7xjlt74FT0SWYfE,110
-Werkzeug-0.14.1.dist-info/metadata.json,sha256=4489UTt6HBp2NQil95-pBkjU4Je93SMHvMxZ_rjOpqA,1452
-Werkzeug-0.14.1.dist-info/top_level.txt,sha256=QRyj2VjwJoQkrwjwFIOlB8Xg3r9un0NtqVHQF-15xaw,9
-werkzeug/__init__.py,sha256=NR0d4n_-U9BLVKlOISean3zUt2vBwhvK-AZE6M0sC0k,6842
-werkzeug/_compat.py,sha256=8c4U9o6A_TR9nKCcTbpZNxpqCXcXDVIbFawwKM2s92c,6311
-werkzeug/_internal.py,sha256=GhEyGMlsSz_tYjsDWO9TG35VN7304MM8gjKDrXLEdVc,13873
-werkzeug/_reloader.py,sha256=AyPphcOHPbu6qzW0UbrVvTDJdre5WgpxbhIJN_TqzUc,9264
-werkzeug/datastructures.py,sha256=3IgNKNqrz-ZjmAG7y3YgEYK-enDiMT_b652PsypWcYg,90080
-werkzeug/exceptions.py,sha256=3wp95Hqj9FqV8MdikV99JRcHse_fSMn27V8tgP5Hw2c,20505
-werkzeug/filesystem.py,sha256=hHWeWo_gqLMzTRfYt8-7n2wWcWUNTnDyudQDLOBEICE,2175
-werkzeug/formparser.py,sha256=mUuCwjzjb8_E4RzrAT2AioLuZSYpqR1KXTK6LScRYzA,21722
-werkzeug/http.py,sha256=RQg4MJuhRv2isNRiEh__Phh09ebpfT3Kuu_GfrZ54_c,40079
-werkzeug/local.py,sha256=QdQhWV5L8p1Y1CJ1CDStwxaUs24SuN5aebHwjVD08C8,14553
-werkzeug/posixemulation.py,sha256=xEF2Bxc-vUCPkiu4IbfWVd3LW7DROYAT-ExW6THqyzw,3519
-werkzeug/routing.py,sha256=2JVtdSgxKGeANy4Z_FP-dKESvKtkYGCZ1J2fARCLGCY,67214
-werkzeug/script.py,sha256=DwaVDcXdaOTffdNvlBdLitxWXjKaRVT32VbhDtljFPY,11365
-werkzeug/security.py,sha256=0m107exslz4QJLWQCpfQJ04z3re4eGHVggRvrQVAdWc,9193
-werkzeug/serving.py,sha256=A0flnIJHufdn2QJ9oeuHfrXwP3LzP8fn3rNW6hbxKUg,31926
-werkzeug/test.py,sha256=XmECSmnpASiYQTct4oMiWr0LT5jHWCtKqnpYKZd2ui8,36100
-werkzeug/testapp.py,sha256=3HQRW1sHZKXuAjCvFMet4KXtQG3loYTFnvn6LWt-4zI,9396
-werkzeug/urls.py,sha256=dUeLg2IeTm0WLmSvFeD4hBZWGdOs-uHudR5-t8n9zPo,36771
-werkzeug/useragents.py,sha256=BhYMf4cBTHyN4U0WsQedePIocmNlH_34C-UwqSThGCc,5865
-werkzeug/utils.py,sha256=BrY1j0DHQ8RTb0K1StIobKuMJhN9SQQkWEARbrh2qpk,22972
-werkzeug/websocket.py,sha256=PpSeDxXD_0UsPAa5hQhQNM6mxibeUgn8lA8eRqiS0vM,11344
-werkzeug/wrappers.py,sha256=kbyL_aFjxELwPgMwfNCYjKu-CR6kNkh-oO8wv3GXbk8,84511
-werkzeug/wsgi.py,sha256=1Nob-aeChWQf7MsiicO8RZt6J90iRzEcik44ev9Qu8s,49347
-werkzeug/contrib/__init__.py,sha256=f7PfttZhbrImqpr5Ezre8CXgwvcGUJK7zWNpO34WWrw,623
-werkzeug/contrib/atom.py,sha256=qqfJcfIn2RYY-3hO3Oz0aLq9YuNubcPQ_KZcNsDwVJo,15575
-werkzeug/contrib/cache.py,sha256=xBImHNj09BmX_7kC5NUCx8f_l4L8_O7zi0jCL21UZKE,32163
-werkzeug/contrib/fixers.py,sha256=gR06T-w71ur-tHQ_31kP_4jpOncPJ4Wc1dOqTvYusr8,10179
-werkzeug/contrib/iterio.py,sha256=RlqDvGhz0RneTpzE8dVc-yWCUv4nkPl1jEc_EDp2fH0,10814
-werkzeug/contrib/jsrouting.py,sha256=QTmgeDoKXvNK02KzXgx9lr3cAH6fAzpwF5bBdPNvJPs,8564
-werkzeug/contrib/limiter.py,sha256=iS8-ahPZ-JLRnmfIBzxpm7O_s3lPsiDMVWv7llAIDCI,1334
-werkzeug/contrib/lint.py,sha256=Mj9NeUN7s4zIUWeQOAVjrmtZIcl3Mm2yDe9BSIr9YGE,12558
-werkzeug/contrib/profiler.py,sha256=ISwCWvwVyGpDLRBRpLjo_qUWma6GXYBrTAco4PEQSHY,5151
-werkzeug/contrib/securecookie.py,sha256=uWMyHDHY3lkeBRiCSayGqWkAIy4a7xAbSE_Hln9ecqc,12196
-werkzeug/contrib/sessions.py,sha256=39LVNvLbm5JWpbxM79WC2l87MJFbqeISARjwYbkJatw,12577
-werkzeug/contrib/testtools.py,sha256=G9xN-qeihJlhExrIZMCahvQOIDxdL9NiX874jiiHFMs,2453
-werkzeug/contrib/wrappers.py,sha256=v7OYlz7wQtDlS9fey75UiRZ1IkUWqCpzbhsLy4k14Hw,10398
-werkzeug/debug/__init__.py,sha256=uSn9BqCZ5E3ySgpoZtundpROGsn-uYvZtSFiTfAX24M,17452
-werkzeug/debug/console.py,sha256=n3-dsKk1TsjnN-u4ZgmuWCU_HO0qw5IA7ttjhyyMM6I,5607
-werkzeug/debug/repr.py,sha256=bKqstDYGfECpeLerd48s_hxuqK4b6UWnjMu3d_DHO8I,9340
-werkzeug/debug/tbtools.py,sha256=rBudXCmkVdAKIcdhxANxgf09g6kQjJWW9_5bjSpr4OY,18451
-werkzeug/debug/shared/FONT_LICENSE,sha256=LwAVEI1oYnvXiNMT9SnCH_TaLCxCpeHziDrMg0gPkAI,4673
-werkzeug/debug/shared/console.png,sha256=bxax6RXXlvOij_KeqvSNX0ojJf83YbnZ7my-3Gx9w2A,507
-werkzeug/debug/shared/debugger.js,sha256=PKPVYuyO4SX1hkqLOwCLvmIEO5154WatFYaXE-zIfKI,6264
-werkzeug/debug/shared/jquery.js,sha256=7LkWEzqTdpEfELxcZZlS6wAx5Ff13zZ83lYO2_ujj7g,95957
-werkzeug/debug/shared/less.png,sha256=-4-kNRaXJSONVLahrQKUxMwXGm9R4OnZ9SxDGpHlIR4,191
-werkzeug/debug/shared/more.png,sha256=GngN7CioHQoV58rH6ojnkYi8c_qED2Aka5FO5UXrReY,200
-werkzeug/debug/shared/source.png,sha256=RoGcBTE4CyCB85GBuDGTFlAnUqxwTBiIfDqW15EpnUQ,818
-werkzeug/debug/shared/style.css,sha256=IEO0PC2pWmh2aEyGCaN--txuWsRCliuhlbEhPDFwh0A,6270
-werkzeug/debug/shared/ubuntu.ttf,sha256=1eaHFyepmy4FyDvjLVzpITrGEBu_CZYY94jE0nED1c0,70220
-Werkzeug-0.14.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-werkzeug/contrib/__pycache__/atom.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/cache.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/fixers.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/iterio.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/jsrouting.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/limiter.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/lint.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/profiler.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/securecookie.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/sessions.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/testtools.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/wrappers.cpython-36.pyc,,
-werkzeug/contrib/__pycache__/__init__.cpython-36.pyc,,
-werkzeug/debug/__pycache__/console.cpython-36.pyc,,
-werkzeug/debug/__pycache__/repr.cpython-36.pyc,,
-werkzeug/debug/__pycache__/tbtools.cpython-36.pyc,,
-werkzeug/debug/__pycache__/__init__.cpython-36.pyc,,
-werkzeug/__pycache__/datastructures.cpython-36.pyc,,
-werkzeug/__pycache__/exceptions.cpython-36.pyc,,
-werkzeug/__pycache__/filesystem.cpython-36.pyc,,
-werkzeug/__pycache__/formparser.cpython-36.pyc,,
-werkzeug/__pycache__/http.cpython-36.pyc,,
-werkzeug/__pycache__/local.cpython-36.pyc,,
-werkzeug/__pycache__/posixemulation.cpython-36.pyc,,
-werkzeug/__pycache__/routing.cpython-36.pyc,,
-werkzeug/__pycache__/script.cpython-36.pyc,,
-werkzeug/__pycache__/security.cpython-36.pyc,,
-werkzeug/__pycache__/serving.cpython-36.pyc,,
-werkzeug/__pycache__/test.cpython-36.pyc,,
-werkzeug/__pycache__/testapp.cpython-36.pyc,,
-werkzeug/__pycache__/urls.cpython-36.pyc,,
-werkzeug/__pycache__/useragents.cpython-36.pyc,,
-werkzeug/__pycache__/utils.cpython-36.pyc,,
-werkzeug/__pycache__/websocket.cpython-36.pyc,,
-werkzeug/__pycache__/wrappers.cpython-36.pyc,,
-werkzeug/__pycache__/wsgi.cpython-36.pyc,,
-werkzeug/__pycache__/_compat.cpython-36.pyc,,
-werkzeug/__pycache__/_internal.cpython-36.pyc,,
-werkzeug/__pycache__/_reloader.cpython-36.pyc,,
-werkzeug/__pycache__/__init__.cpython-36.pyc,,

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/WHEEL

@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.26.0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/metadata.json

@@ -1 +0,0 @@
-{"generator": "bdist_wheel (0.26.0)", "summary": "The comprehensive WSGI web application library.", "classifiers": ["Development Status :: 5 - Production/Stable", "Environment :: Web Environment", "Intended Audience :: Developers", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python", "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", "Topic :: Internet :: WWW/HTTP :: Dynamic Content", "Topic :: Software Development :: Libraries :: Python Modules"], "description_content_type": "UNKNOWN", "extensions": {"python.details": {"project_urls": {"Home": "https://www.palletsprojects.org/p/werkzeug/"}, "contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst", "license": "LICENSE.txt"}}}, "license": "BSD", "metadata_version": "2.0", "name": "Werkzeug", "platform": "any", "extras": ["dev", "termcolor", "watchdog"], "run_requires": [{"requires": ["coverage", "pytest", "sphinx", "tox"], "extra": "dev"}, {"requires": ["termcolor"], "extra": "termcolor"}, {"requires": ["watchdog"], "extra": "watchdog"}], "version": "0.14.1"}

website/web/Lib/site-packages/Werkzeug-0.14.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-werkzeug

website/web/Lib/site-packages/cffi-1.11.4.dist-info/DESCRIPTION.rst

@@ -1,13 +0,0 @@
-
-CFFI
-====
-
-Foreign Function Interface for Python calling C code.
-Please see the `Documentation <http://cffi.readthedocs.org/>`_.
-
-Contact
--------
-
-`Mailing list <https://groups.google.com/forum/#!forum/python-cffi>`_
-
-

website/web/Lib/site-packages/cffi-1.11.4.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

website/web/Lib/site-packages/cffi-1.11.4.dist-info/METADATA

@@ -1,37 +0,0 @@
-Metadata-Version: 2.0
-Name: cffi
-Version: 1.11.4
-Summary: Foreign Function Interface for Python calling C code.
-Home-page: http://cffi.readthedocs.org
-Author: Armin Rigo, Maciej Fijalkowski
-Author-email: python-cffi@googlegroups.com
-License: MIT
-Description-Content-Type: UNKNOWN
-Platform: UNKNOWN
-Classifier: Programming Language :: Python
-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: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Dist: pycparser
-
-
-CFFI
-====
-
-Foreign Function Interface for Python calling C code.
-Please see the `Documentation <http://cffi.readthedocs.org/>`_.
-
-Contact
--------
-
-`Mailing list <https://groups.google.com/forum/#!forum/python-cffi>`_
-
-

website/web/Lib/site-packages/cffi-1.11.4.dist-info/RECORD

@@ -1,43 +0,0 @@
-_cffi_backend.cp36-win_amd64.pyd,sha256=likuFoX9C7Qi1bfHpJJHzKgOXmWFdXIN1IbPCbmO7bc,170496
-cffi/__init__.py,sha256=mewOsqyqnxYpvL3XfQFIRYyxcoW2ic60hMResP7gdJM,479
-cffi/_cffi_errors.h,sha256=NLNuKgpRUJ4x0ku4pi-Pe1vT1mzovxBTeHjPZTxCB7U,3804
-cffi/_cffi_include.h,sha256=JuFfmwpRE65vym3Nxr9vDMOIEuv21tXdarkL1l2WNms,12149
-cffi/_embedding.h,sha256=iSs9APxG4SDy_ahlyV1s46_lvWdVBxnuOwaEBN5jOUg,17643
-cffi/api.py,sha256=eUXlc8fTxiS3PjpfBU3sMi8gVgeG4yIsPA6teyNWehI,40221
-cffi/backend_ctypes.py,sha256=XxMfz3Kn_QZhvLLqNXmIL_Z9M8CGlGAa1YWtH6k8wYQ,42086
-cffi/cffi_opcode.py,sha256=v9RdD_ovA8rCtqsC95Ivki5V667rAOhGgs3fb2q9xpM,5724
-cffi/commontypes.py,sha256=QS4uxCDI7JhtTyjh1hlnCA-gynmaszWxJaRRLGkJa1A,2689
-cffi/cparser.py,sha256=R0_gdB8vL1YNf-W5G_5KvV1pOTnZwvuLeioaDvODI6c,39250
-cffi/error.py,sha256=L_J76qbh6LSxH4A64muOUwJKL6zVHC32E3gG1ntUM-A,666
-cffi/ffiplatform.py,sha256=HMXqR8ks2wtdsNxGaWpQ_PyqIvtiuos_vf1qKCy-cwg,4046
-cffi/lock.py,sha256=l9TTdwMIMpi6jDkJGnQgE9cvTIR7CAntIJr8EGHt3pY,747
-cffi/model.py,sha256=-ZXCFO_EPbX3zN3ecx4H2rR0MZZA16ZwldDuv3CzJXU,21495
-cffi/parse_c_type.h,sha256=OdwQfwM9ktq6vlCB43exFQmxDBtj2MBNdK8LYl15tjw,5976
-cffi/recompiler.py,sha256=4qpl0bOTaegsWJbaCvjtRh4q6KH5hWZurnKK1YGEeRk,63092
-cffi/setuptools_ext.py,sha256=6K2HJn-qNTQL-FvILZCH0T90MR6FVelFClL4f8ZCWaQ,7682
-cffi/vengine_cpy.py,sha256=hdyjjZNijLrg_uGMnnFyC-7GG_LxWtwB8BlS2vvVDQ0,41470
-cffi/vengine_gen.py,sha256=Zkq0-EdeZwn6qUvf_CI8iUEs2UxVIvDmKCH1j0-y0GI,26676
-cffi/verifier.py,sha256=J9Enz2rbJb9CHPqWlWQ5uQESoyr0uc7MNWugchjXBv4,11207
-cffi-1.11.4.dist-info/DESCRIPTION.rst,sha256=9ijQLbcqTWNF-iV0RznFiBeBCNrjArA0P-eutKUPw98,220
-cffi-1.11.4.dist-info/METADATA,sha256=uiGWsWy8zEb_-R4-vMutpELIrBKsvCV-_soHfZNjUaw,1174
-cffi-1.11.4.dist-info/RECORD,,
-cffi-1.11.4.dist-info/WHEEL,sha256=3o6dJ54ci-MtRFdJCPkLCK5G-vO7QSv3lIQ-NrhglGk,106
-cffi-1.11.4.dist-info/entry_points.txt,sha256=Q9f5C9IpjYxo0d2PK9eUcnkgxHc9pHWwjEMaANPKNCI,76
-cffi-1.11.4.dist-info/metadata.json,sha256=8S4WNSCRPXo6P__ARsF2aUGV0Drrh82dQQxr9Xsj9vw,1192
-cffi-1.11.4.dist-info/top_level.txt,sha256=rE7WR3rZfNKxWI9-jn6hsHCAl7MDkB-FmuQbxWjFehQ,19
-cffi-1.11.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-cffi/__pycache__/api.cpython-36.pyc,,
-cffi/__pycache__/backend_ctypes.cpython-36.pyc,,
-cffi/__pycache__/cffi_opcode.cpython-36.pyc,,
-cffi/__pycache__/commontypes.cpython-36.pyc,,
-cffi/__pycache__/cparser.cpython-36.pyc,,
-cffi/__pycache__/error.cpython-36.pyc,,
-cffi/__pycache__/ffiplatform.cpython-36.pyc,,
-cffi/__pycache__/lock.cpython-36.pyc,,
-cffi/__pycache__/model.cpython-36.pyc,,
-cffi/__pycache__/recompiler.cpython-36.pyc,,
-cffi/__pycache__/setuptools_ext.cpython-36.pyc,,
-cffi/__pycache__/vengine_cpy.cpython-36.pyc,,
-cffi/__pycache__/vengine_gen.cpython-36.pyc,,
-cffi/__pycache__/verifier.cpython-36.pyc,,
-cffi/__pycache__/__init__.cpython-36.pyc,,

website/web/Lib/site-packages/cffi-1.11.4.dist-info/WHEEL

@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.30.0)
-Root-Is-Purelib: false
-Tag: cp36-cp36m-win_amd64
-

website/web/Lib/site-packages/cffi-1.11.4.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[distutils.setup_keywords]
-cffi_modules = cffi.setuptools_ext:cffi_modules
-

website/web/Lib/site-packages/cffi-1.11.4.dist-info/metadata.json

@@ -1 +0,0 @@
-{"classifiers": ["Programming Language :: Python", "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", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: Implementation :: CPython", "Programming Language :: Python :: Implementation :: PyPy"], "description_content_type": "UNKNOWN", "extensions": {"python.details": {"contacts": [{"email": "python-cffi@googlegroups.com", "name": "Armin Rigo, Maciej Fijalkowski", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "http://cffi.readthedocs.org"}}, "python.exports": {"distutils.setup_keywords": {"cffi_modules": "cffi.setuptools_ext:cffi_modules"}}}, "extras": [], "generator": "bdist_wheel (0.30.0)", "license": "MIT", "metadata_version": "2.0", "name": "cffi", "run_requires": [{"requires": ["pycparser"]}], "summary": "Foreign Function Interface for Python calling C code.", "version": "1.11.4"}

website/web/Lib/site-packages/cffi-1.11.4.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-_cffi_backend
-cffi

website/web/Lib/site-packages/cffi/__init__.py

@@ -1,13 +0,0 @@
-__all__ = ['FFI', 'VerificationError', 'VerificationMissing', 'CDefError',
-           'FFIError']
-
-from .api import FFI
-from .error import CDefError, FFIError, VerificationError, VerificationMissing
-
-__version__ = "1.11.4"
-__version_info__ = (1, 11, 4)
-
-# The verifier module file names are based on the CRC32 of a string that
-# contains the following version number.  It may be older than __version__
-# if nothing is clearly incompatible.
-__version_verifier_modules__ = "0.8.6"

website/web/Lib/site-packages/cffi/_cffi_errors.h

@@ -1,145 +0,0 @@
-#ifndef CFFI_MESSAGEBOX
-# ifdef _MSC_VER
-#  define CFFI_MESSAGEBOX  1
-# else
-#  define CFFI_MESSAGEBOX  0
-# endif
-#endif
-
-
-#if CFFI_MESSAGEBOX
-/* Windows only: logic to take the Python-CFFI embedding logic
-   initialization errors and display them in a background thread
-   with MessageBox.  The idea is that if the whole program closes
-   as a result of this problem, then likely it is already a console
-   program and you can read the stderr output in the console too.
-   If it is not a console program, then it will likely show its own
-   dialog to complain, or generally not abruptly close, and for this
-   case the background thread should stay alive.
-*/
-static void *volatile _cffi_bootstrap_text;
-
-static PyObject *_cffi_start_error_capture(void)
-{
-    PyObject *result = NULL;
-    PyObject *x, *m, *bi;
-
-    if (InterlockedCompareExchangePointer(&_cffi_bootstrap_text,
-            (void *)1, NULL) != NULL)
-        return (PyObject *)1;
-
-    m = PyImport_AddModule("_cffi_error_capture");
-    if (m == NULL)
-        goto error;
-
-    result = PyModule_GetDict(m);
-    if (result == NULL)
-        goto error;
-
-#if PY_MAJOR_VERSION >= 3
-    bi = PyImport_ImportModule("builtins");
-#else
-    bi = PyImport_ImportModule("__builtin__");
-#endif
-    if (bi == NULL)
-        goto error;
-    PyDict_SetItemString(result, "__builtins__", bi);
-    Py_DECREF(bi);
-
-    x = PyRun_String(
-        "import sys\n"
-        "class FileLike:\n"
-        "  def write(self, x):\n"
-        "    of.write(x)\n"
-        "    self.buf += x\n"
-        "fl = FileLike()\n"
-        "fl.buf = ''\n"
-        "of = sys.stderr\n"
-        "sys.stderr = fl\n"
-        "def done():\n"
-        "  sys.stderr = of\n"
-        "  return fl.buf\n",   /* make sure the returned value stays alive */
-        Py_file_input,
-        result, result);
-    Py_XDECREF(x);
-
- error:
-    if (PyErr_Occurred())
-    {
-        PyErr_WriteUnraisable(Py_None);
-        PyErr_Clear();
-    }
-    return result;
-}
-
-#pragma comment(lib, "user32.lib")
-
-static DWORD WINAPI _cffi_bootstrap_dialog(LPVOID ignored)
-{
-    Sleep(666);    /* may be interrupted if the whole process is closing */
-#if PY_MAJOR_VERSION >= 3
-    MessageBoxW(NULL, (wchar_t *)_cffi_bootstrap_text,
-                L"Python-CFFI error",
-                MB_OK | MB_ICONERROR);
-#else
-    MessageBoxA(NULL, (char *)_cffi_bootstrap_text,
-                "Python-CFFI error",
-                MB_OK | MB_ICONERROR);
-#endif
-    _cffi_bootstrap_text = NULL;
-    return 0;
-}
-
-static void _cffi_stop_error_capture(PyObject *ecap)
-{
-    PyObject *s;
-    void *text;
-
-    if (ecap == (PyObject *)1)
-        return;
-
-    if (ecap == NULL)
-        goto error;
-
-    s = PyRun_String("done()", Py_eval_input, ecap, ecap);
-    if (s == NULL)
-        goto error;
-
-    /* Show a dialog box, but in a background thread, and
-       never show multiple dialog boxes at once. */
-#if PY_MAJOR_VERSION >= 3
-    text = PyUnicode_AsWideCharString(s, NULL);
-#else
-    text = PyString_AsString(s);
-#endif
-
-    _cffi_bootstrap_text = text;
-
-    if (text != NULL)
-    {
-        HANDLE h;
-        h = CreateThread(NULL, 0, _cffi_bootstrap_dialog,
-                         NULL, 0, NULL);
-        if (h != NULL)
-            CloseHandle(h);
-    }
-    /* decref the string, but it should stay alive as 'fl.buf'
-       in the small module above.  It will really be freed only if
-       we later get another similar error.  So it's a leak of at
-       most one copy of the small module.  That's fine for this
-       situation which is usually a "fatal error" anyway. */
-    Py_DECREF(s);
-    PyErr_Clear();
-    return;
-
-  error:
-    _cffi_bootstrap_text = NULL;
-    PyErr_Clear();
-}
-
-#else
-
-static PyObject *_cffi_start_error_capture(void) { return NULL; }
-static void _cffi_stop_error_capture(PyObject *ecap) { }
-
-#endif

website/web/Lib/site-packages/cffi/_cffi_include.h

@@ -1,308 +0,0 @@
-#define _CFFI_
-
-/* We try to define Py_LIMITED_API before including Python.h.
-
-   Mess: we can only define it if Py_DEBUG, Py_TRACE_REFS and
-   Py_REF_DEBUG are not defined.  This is a best-effort approximation:
-   we can learn about Py_DEBUG from pyconfig.h, but it is unclear if
-   the same works for the other two macros.  Py_DEBUG implies them,
-   but not the other way around.
-
-   Issue #350 is still open: on Windows, the code here causes it to link
-   with PYTHON36.DLL (for example) instead of PYTHON3.DLL.  A fix was
-   attempted in 164e526a5515 and 14ce6985e1c3, but reverted: virtualenv
-   does not make PYTHON3.DLL available, and so the "correctly" compiled
-   version would not run inside a virtualenv.  We will re-apply the fix
-   after virtualenv has been fixed for some time.  For explanation, see
-   issue #355.  For a workaround if you want PYTHON3.DLL and don't worry
-   about virtualenv, see issue #350.  See also 'py_limited_api' in
-   setuptools_ext.py.
-*/
-#if !defined(_CFFI_USE_EMBEDDING) && !defined(Py_LIMITED_API)
-#  include <pyconfig.h>
-#  if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS) && !defined(Py_REF_DEBUG)
-#    define Py_LIMITED_API
-#  endif
-#endif
-
-#include <Python.h>
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <stddef.h>
-#include "parse_c_type.h"
-
-/* this block of #ifs should be kept exactly identical between
-   c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py
-   and cffi/_cffi_include.h */
-#if defined(_MSC_VER)
-# include <malloc.h>   /* for alloca() */
-# if _MSC_VER < 1600   /* MSVC < 2010 */
-   typedef __int8 int8_t;
-   typedef __int16 int16_t;
-   typedef __int32 int32_t;
-   typedef __int64 int64_t;
-   typedef unsigned __int8 uint8_t;
-   typedef unsigned __int16 uint16_t;
-   typedef unsigned __int32 uint32_t;
-   typedef unsigned __int64 uint64_t;
-   typedef __int8 int_least8_t;
-   typedef __int16 int_least16_t;
-   typedef __int32 int_least32_t;
-   typedef __int64 int_least64_t;
-   typedef unsigned __int8 uint_least8_t;
-   typedef unsigned __int16 uint_least16_t;
-   typedef unsigned __int32 uint_least32_t;
-   typedef unsigned __int64 uint_least64_t;
-   typedef __int8 int_fast8_t;
-   typedef __int16 int_fast16_t;
-   typedef __int32 int_fast32_t;
-   typedef __int64 int_fast64_t;
-   typedef unsigned __int8 uint_fast8_t;
-   typedef unsigned __int16 uint_fast16_t;
-   typedef unsigned __int32 uint_fast32_t;
-   typedef unsigned __int64 uint_fast64_t;
-   typedef __int64 intmax_t;
-   typedef unsigned __int64 uintmax_t;
-# else
-#  include <stdint.h>
-# endif
-# if _MSC_VER < 1800   /* MSVC < 2013 */
-#  ifndef __cplusplus
-    typedef unsigned char _Bool;
-#  endif
-# endif
-#else
-# include <stdint.h>
-# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux)
-#  include <alloca.h>
-# endif
-#endif
-
-#ifdef __GNUC__
-# define _CFFI_UNUSED_FN  __attribute__((unused))
-#else
-# define _CFFI_UNUSED_FN  /* nothing */
-#endif
-
-#ifdef __cplusplus
-# ifndef _Bool
-   typedef bool _Bool;   /* semi-hackish: C++ has no _Bool; bool is builtin */
-# endif
-#endif
-
-/**********  CPython-specific section  **********/
-#ifndef PYPY_VERSION
-
-
-#if PY_MAJOR_VERSION >= 3
-# define PyInt_FromLong PyLong_FromLong
-#endif
-
-#define _cffi_from_c_double PyFloat_FromDouble
-#define _cffi_from_c_float PyFloat_FromDouble
-#define _cffi_from_c_long PyInt_FromLong
-#define _cffi_from_c_ulong PyLong_FromUnsignedLong
-#define _cffi_from_c_longlong PyLong_FromLongLong
-#define _cffi_from_c_ulonglong PyLong_FromUnsignedLongLong
-#define _cffi_from_c__Bool PyBool_FromLong
-
-#define _cffi_to_c_double PyFloat_AsDouble
-#define _cffi_to_c_float PyFloat_AsDouble
-
-#define _cffi_from_c_int(x, type)                                        \
-    (((type)-1) > 0 ? /* unsigned */                                     \
-        (sizeof(type) < sizeof(long) ?                                   \
-            PyInt_FromLong((long)x) :                                    \
-         sizeof(type) == sizeof(long) ?                                  \
-            PyLong_FromUnsignedLong((unsigned long)x) :                  \
-            PyLong_FromUnsignedLongLong((unsigned long long)x)) :        \
-        (sizeof(type) <= sizeof(long) ?                                  \
-            PyInt_FromLong((long)x) :                                    \
-            PyLong_FromLongLong((long long)x)))
-
-#define _cffi_to_c_int(o, type)                                          \
-    ((type)(                                                             \
-     sizeof(type) == 1 ? (((type)-1) > 0 ? (type)_cffi_to_c_u8(o)        \
-                                         : (type)_cffi_to_c_i8(o)) :     \
-     sizeof(type) == 2 ? (((type)-1) > 0 ? (type)_cffi_to_c_u16(o)       \
-                                         : (type)_cffi_to_c_i16(o)) :    \
-     sizeof(type) == 4 ? (((type)-1) > 0 ? (type)_cffi_to_c_u32(o)       \
-                                         : (type)_cffi_to_c_i32(o)) :    \
-     sizeof(type) == 8 ? (((type)-1) > 0 ? (type)_cffi_to_c_u64(o)       \
-                                         : (type)_cffi_to_c_i64(o)) :    \
-     (Py_FatalError("unsupported size for type " #type), (type)0)))
-
-#define _cffi_to_c_i8                                                    \
-                 ((int(*)(PyObject *))_cffi_exports[1])
-#define _cffi_to_c_u8                                                    \
-                 ((int(*)(PyObject *))_cffi_exports[2])
-#define _cffi_to_c_i16                                                   \
-                 ((int(*)(PyObject *))_cffi_exports[3])
-#define _cffi_to_c_u16                                                   \
-                 ((int(*)(PyObject *))_cffi_exports[4])
-#define _cffi_to_c_i32                                                   \
-                 ((int(*)(PyObject *))_cffi_exports[5])
-#define _cffi_to_c_u32                                                   \
-                 ((unsigned int(*)(PyObject *))_cffi_exports[6])
-#define _cffi_to_c_i64                                                   \
-                 ((long long(*)(PyObject *))_cffi_exports[7])
-#define _cffi_to_c_u64                                                   \
-                 ((unsigned long long(*)(PyObject *))_cffi_exports[8])
-#define _cffi_to_c_char                                                  \
-                 ((int(*)(PyObject *))_cffi_exports[9])
-#define _cffi_from_c_pointer                                             \
-    ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[10])
-#define _cffi_to_c_pointer                                               \
-    ((char *(*)(PyObject *, struct _cffi_ctypedescr *))_cffi_exports[11])
-#define _cffi_get_struct_layout                                          \
-    not used any more
-#define _cffi_restore_errno                                              \
-    ((void(*)(void))_cffi_exports[13])
-#define _cffi_save_errno                                                 \
-    ((void(*)(void))_cffi_exports[14])
-#define _cffi_from_c_char                                                \
-    ((PyObject *(*)(char))_cffi_exports[15])
-#define _cffi_from_c_deref                                               \
-    ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[16])
-#define _cffi_to_c                                                       \
-    ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[17])
-#define _cffi_from_c_struct                                              \
-    ((PyObject *(*)(char *, struct _cffi_ctypedescr *))_cffi_exports[18])
-#define _cffi_to_c_wchar_t                                               \
-    ((_cffi_wchar_t(*)(PyObject *))_cffi_exports[19])
-#define _cffi_from_c_wchar_t                                             \
-    ((PyObject *(*)(_cffi_wchar_t))_cffi_exports[20])
-#define _cffi_to_c_long_double                                           \
-    ((long double(*)(PyObject *))_cffi_exports[21])
-#define _cffi_to_c__Bool                                                 \
-    ((_Bool(*)(PyObject *))_cffi_exports[22])
-#define _cffi_prepare_pointer_call_argument                              \
-    ((Py_ssize_t(*)(struct _cffi_ctypedescr *,                           \
-                    PyObject *, char **))_cffi_exports[23])
-#define _cffi_convert_array_from_object                                  \
-    ((int(*)(char *, struct _cffi_ctypedescr *, PyObject *))_cffi_exports[24])
-#define _CFFI_CPIDX  25
-#define _cffi_call_python                                                \
-    ((void(*)(struct _cffi_externpy_s *, char *))_cffi_exports[_CFFI_CPIDX])
-#define _cffi_to_c_wchar3216_t                                           \
-    ((int(*)(PyObject *))_cffi_exports[26])
-#define _cffi_from_c_wchar3216_t                                         \
-    ((PyObject *(*)(int))_cffi_exports[27])
-#define _CFFI_NUM_EXPORTS 28
-
-struct _cffi_ctypedescr;
-
-static void *_cffi_exports[_CFFI_NUM_EXPORTS];
-
-#define _cffi_type(index)   (                           \
-    assert((((uintptr_t)_cffi_types[index]) & 1) == 0), \
-    (struct _cffi_ctypedescr *)_cffi_types[index])
-
-static PyObject *_cffi_init(const char *module_name, Py_ssize_t version,
-                            const struct _cffi_type_context_s *ctx)
-{
-    PyObject *module, *o_arg, *new_module;
-    void *raw[] = {
-        (void *)module_name,
-        (void *)version,
-        (void *)_cffi_exports,
-        (void *)ctx,
-    };
-
-    module = PyImport_ImportModule("_cffi_backend");
-    if (module == NULL)
-        goto failure;
-
-    o_arg = PyLong_FromVoidPtr((void *)raw);
-    if (o_arg == NULL)
-        goto failure;
-
-    new_module = PyObject_CallMethod(
-        module, (char *)"_init_cffi_1_0_external_module", (char *)"O", o_arg);
-
-    Py_DECREF(o_arg);
-    Py_DECREF(module);
-    return new_module;
-
-  failure:
-    Py_XDECREF(module);
-    return NULL;
-}
-
-
-#ifdef HAVE_WCHAR_H
-typedef wchar_t _cffi_wchar_t;
-#else
-typedef uint16_t _cffi_wchar_t;   /* same random pick as _cffi_backend.c */
-#endif
-
-_CFFI_UNUSED_FN static uint16_t _cffi_to_c_char16_t(PyObject *o)
-{
-    if (sizeof(_cffi_wchar_t) == 2)
-        return (uint16_t)_cffi_to_c_wchar_t(o);
-    else
-        return (uint16_t)_cffi_to_c_wchar3216_t(o);
-}
-
-_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char16_t(uint16_t x)
-{
-    if (sizeof(_cffi_wchar_t) == 2)
-        return _cffi_from_c_wchar_t((_cffi_wchar_t)x);
-    else
-        return _cffi_from_c_wchar3216_t((int)x);
-}
-
-_CFFI_UNUSED_FN static int _cffi_to_c_char32_t(PyObject *o)
-{
-    if (sizeof(_cffi_wchar_t) == 4)
-        return (int)_cffi_to_c_wchar_t(o);
-    else
-        return (int)_cffi_to_c_wchar3216_t(o);
-}
-
-_CFFI_UNUSED_FN static PyObject *_cffi_from_c_char32_t(int x)
-{
-    if (sizeof(_cffi_wchar_t) == 4)
-        return _cffi_from_c_wchar_t((_cffi_wchar_t)x);
-    else
-        return _cffi_from_c_wchar3216_t(x);
-}
-
-
-/**********  end CPython-specific section  **********/
-#else
-_CFFI_UNUSED_FN
-static void (*_cffi_call_python_org)(struct _cffi_externpy_s *, char *);
-# define _cffi_call_python  _cffi_call_python_org
-#endif
-
-
-#define _cffi_array_len(array)   (sizeof(array) / sizeof((array)[0]))
-
-#define _cffi_prim_int(size, sign)                                      \
-    ((size) == 1 ? ((sign) ? _CFFI_PRIM_INT8  : _CFFI_PRIM_UINT8)  :    \
-     (size) == 2 ? ((sign) ? _CFFI_PRIM_INT16 : _CFFI_PRIM_UINT16) :    \
-     (size) == 4 ? ((sign) ? _CFFI_PRIM_INT32 : _CFFI_PRIM_UINT32) :    \
-     (size) == 8 ? ((sign) ? _CFFI_PRIM_INT64 : _CFFI_PRIM_UINT64) :    \
-     _CFFI__UNKNOWN_PRIM)
-
-#define _cffi_prim_float(size)                                          \
-    ((size) == sizeof(float) ? _CFFI_PRIM_FLOAT :                       \
-     (size) == sizeof(double) ? _CFFI_PRIM_DOUBLE :                     \
-     (size) == sizeof(long double) ? _CFFI__UNKNOWN_LONG_DOUBLE :       \
-     _CFFI__UNKNOWN_FLOAT_PRIM)
-
-#define _cffi_check_int(got, got_nonpos, expected)      \
-    ((got_nonpos) == (expected <= 0) &&                 \
-     (got) == (unsigned long long)expected)
-
-#ifdef MS_WIN32
-# define _cffi_stdcall  __stdcall
-#else
-# define _cffi_stdcall  /* nothing */
-#endif
-
-#ifdef __cplusplus
-}
-#endif

website/web/Lib/site-packages/cffi/_embedding.h

@@ -1,536 +0,0 @@
-
-/***** Support code for embedding *****/
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-#if defined(_WIN32)
-#  define CFFI_DLLEXPORT  __declspec(dllexport)
-#elif defined(__GNUC__)
-#  define CFFI_DLLEXPORT  __attribute__((visibility("default")))
-#else
-#  define CFFI_DLLEXPORT  /* nothing */
-#endif
-
-
-/* There are two global variables of type _cffi_call_python_fnptr:
-
-   * _cffi_call_python, which we declare just below, is the one called
-     by ``extern "Python"`` implementations.
-
-   * _cffi_call_python_org, which on CPython is actually part of the
-     _cffi_exports[] array, is the function pointer copied from
-     _cffi_backend.
-
-   After initialization is complete, both are equal.  However, the
-   first one remains equal to &_cffi_start_and_call_python until the
-   very end of initialization, when we are (or should be) sure that
-   concurrent threads also see a completely initialized world, and
-   only then is it changed.
-*/
-#undef _cffi_call_python
-typedef void (*_cffi_call_python_fnptr)(struct _cffi_externpy_s *, char *);
-static void _cffi_start_and_call_python(struct _cffi_externpy_s *, char *);
-static _cffi_call_python_fnptr _cffi_call_python = &_cffi_start_and_call_python;
-
-
-#ifndef _MSC_VER
-   /* --- Assuming a GCC not infinitely old --- */
-# define cffi_compare_and_swap(l,o,n)  __sync_bool_compare_and_swap(l,o,n)
-# define cffi_write_barrier()          __sync_synchronize()
-# if !defined(__amd64__) && !defined(__x86_64__) &&   \
-     !defined(__i386__) && !defined(__i386)
-#   define cffi_read_barrier()         __sync_synchronize()
-# else
-#   define cffi_read_barrier()         (void)0
-# endif
-#else
-   /* --- Windows threads version --- */
-# include <Windows.h>
-# define cffi_compare_and_swap(l,o,n) \
-                               (InterlockedCompareExchangePointer(l,n,o) == (o))
-# define cffi_write_barrier()       InterlockedCompareExchange(&_cffi_dummy,0,0)
-# define cffi_read_barrier()           (void)0
-static volatile LONG _cffi_dummy;
-#endif
-
-#ifdef WITH_THREAD
-# ifndef _MSC_VER
-#  include <pthread.h>
-   static pthread_mutex_t _cffi_embed_startup_lock;
-# else
-   static CRITICAL_SECTION _cffi_embed_startup_lock;
-# endif
-  static char _cffi_embed_startup_lock_ready = 0;
-#endif
-
-static void _cffi_acquire_reentrant_mutex(void)
-{
-    static void *volatile lock = NULL;
-
-    while (!cffi_compare_and_swap(&lock, NULL, (void *)1)) {
-        /* should ideally do a spin loop instruction here, but
-           hard to do it portably and doesn't really matter I
-           think: pthread_mutex_init() should be very fast, and
-           this is only run at start-up anyway. */
-    }
-
-#ifdef WITH_THREAD
-    if (!_cffi_embed_startup_lock_ready) {
-# ifndef _MSC_VER
-        pthread_mutexattr_t attr;
-        pthread_mutexattr_init(&attr);
-        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
-        pthread_mutex_init(&_cffi_embed_startup_lock, &attr);
-# else
-        InitializeCriticalSection(&_cffi_embed_startup_lock);
-# endif
-        _cffi_embed_startup_lock_ready = 1;
-    }
-#endif
-
-    while (!cffi_compare_and_swap(&lock, (void *)1, NULL))
-        ;
-
-#ifndef _MSC_VER
-    pthread_mutex_lock(&_cffi_embed_startup_lock);
-#else
-    EnterCriticalSection(&_cffi_embed_startup_lock);
-#endif
-}
-
-static void _cffi_release_reentrant_mutex(void)
-{
-#ifndef _MSC_VER
-    pthread_mutex_unlock(&_cffi_embed_startup_lock);
-#else
-    LeaveCriticalSection(&_cffi_embed_startup_lock);
-#endif
-}
-
-
-/**********  CPython-specific section  **********/
-#ifndef PYPY_VERSION
-
-#include "_cffi_errors.h"
-
-
-#define _cffi_call_python_org  _cffi_exports[_CFFI_CPIDX]
-
-PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(void);   /* forward */
-
-static void _cffi_py_initialize(void)
-{
-    /* XXX use initsigs=0, which "skips initialization registration of
-       signal handlers, which might be useful when Python is
-       embedded" according to the Python docs.  But review and think
-       if it should be a user-controllable setting.
-
-       XXX we should also give a way to write errors to a buffer
-       instead of to stderr.
-
-       XXX if importing 'site' fails, CPython (any version) calls
-       exit().  Should we try to work around this behavior here?
-    */
-    Py_InitializeEx(0);
-}
-
-static int _cffi_initialize_python(void)
-{
-    /* This initializes Python, imports _cffi_backend, and then the
-       present .dll/.so is set up as a CPython C extension module.
-    */
-    int result;
-    PyGILState_STATE state;
-    PyObject *pycode=NULL, *global_dict=NULL, *x;
-
-#if PY_MAJOR_VERSION >= 3
-    /* see comments in _cffi_carefully_make_gil() about the
-       Python2/Python3 difference 
-    */
-#else
-    /* Acquire the GIL.  We have no threadstate here.  If Python is 
-       already initialized, it is possible that there is already one
-       existing for this thread, but it is not made current now.
-    */
-    PyEval_AcquireLock();
-
-    _cffi_py_initialize();
-
-    /* The Py_InitializeEx() sometimes made a threadstate for us, but
-       not always.  Indeed Py_InitializeEx() could be called and do
-       nothing.  So do we have a threadstate, or not?  We don't know,
-       but we can replace it with NULL in all cases.
-    */
-    (void)PyThreadState_Swap(NULL);
-
-    /* Now we can release the GIL and re-acquire immediately using the
-       logic of PyGILState(), which handles making or installing the
-       correct threadstate.
-    */
-    PyEval_ReleaseLock();
-#endif
-    state = PyGILState_Ensure();
-
-    /* Call the initxxx() function from the present module.  It will
-       create and initialize us as a CPython extension module, instead
-       of letting the startup Python code do it---it might reimport
-       the same .dll/.so and get maybe confused on some platforms.
-       It might also have troubles locating the .dll/.so again for all
-       I know.
-    */
-    (void)_CFFI_PYTHON_STARTUP_FUNC();
-    if (PyErr_Occurred())
-        goto error;
-
-    /* Now run the Python code provided to ffi.embedding_init_code().
-     */
-    pycode = Py_CompileString(_CFFI_PYTHON_STARTUP_CODE,
-                              "<init code for '" _CFFI_MODULE_NAME "'>",
-                              Py_file_input);
-    if (pycode == NULL)
-        goto error;
-    global_dict = PyDict_New();
-    if (global_dict == NULL)
-        goto error;
-    if (PyDict_SetItemString(global_dict, "__builtins__",
-                             PyThreadState_GET()->interp->builtins) < 0)
-        goto error;
-    x = PyEval_EvalCode(
-#if PY_MAJOR_VERSION < 3
-                        (PyCodeObject *)
-#endif
-                        pycode, global_dict, global_dict);
-    if (x == NULL)
-        goto error;
-    Py_DECREF(x);
-
-    /* Done!  Now if we've been called from
-       _cffi_start_and_call_python() in an ``extern "Python"``, we can
-       only hope that the Python code did correctly set up the
-       corresponding @ffi.def_extern() function.  Otherwise, the
-       general logic of ``extern "Python"`` functions (inside the
-       _cffi_backend module) will find that the reference is still
-       missing and print an error.
-     */
-    result = 0;
- done:
-    Py_XDECREF(pycode);
-    Py_XDECREF(global_dict);
-    PyGILState_Release(state);
-    return result;
-
- error:;
-    {
-        /* Print as much information as potentially useful.
-           Debugging load-time failures with embedding is not fun
-        */
-        PyObject *ecap;
-        PyObject *exception, *v, *tb, *f, *modules, *mod;
-        PyErr_Fetch(&exception, &v, &tb);
-        ecap = _cffi_start_error_capture();
-        f = PySys_GetObject((char *)"stderr");
-        if (f != NULL && f != Py_None) {
-            PyFile_WriteString(
-                "Failed to initialize the Python-CFFI embedding logic:\n\n", f);
-        }
-
-        if (exception != NULL) {
-            PyErr_NormalizeException(&exception, &v, &tb);
-            PyErr_Display(exception, v, tb);
-        }
-        Py_XDECREF(exception);
-        Py_XDECREF(v);
-        Py_XDECREF(tb);
-
-        if (f != NULL && f != Py_None) {
-            PyFile_WriteString("\nFrom: " _CFFI_MODULE_NAME
-                               "\ncompiled with cffi version: 1.11.4"
-                               "\n_cffi_backend module: ", f);
-            modules = PyImport_GetModuleDict();
-            mod = PyDict_GetItemString(modules, "_cffi_backend");
-            if (mod == NULL) {
-                PyFile_WriteString("not loaded", f);
-            }
-            else {
-                v = PyObject_GetAttrString(mod, "__file__");
-                PyFile_WriteObject(v, f, 0);
-                Py_XDECREF(v);
-            }
-            PyFile_WriteString("\nsys.path: ", f);
-            PyFile_WriteObject(PySys_GetObject((char *)"path"), f, 0);
-            PyFile_WriteString("\n\n", f);
-        }
-        _cffi_stop_error_capture(ecap);
-    }
-    result = -1;
-    goto done;
-}
-
-PyAPI_DATA(char *) _PyParser_TokenNames[];  /* from CPython */
-
-static int _cffi_carefully_make_gil(void)
-{
-    /* This does the basic initialization of Python.  It can be called
-       completely concurrently from unrelated threads.  It assumes
-       that we don't hold the GIL before (if it exists), and we don't
-       hold it afterwards.
-
-       What it really does is completely different in Python 2 and 
-       Python 3.
-
-    Python 2
-    ========
-
-       Initialize the GIL, without initializing the rest of Python,
-       by calling PyEval_InitThreads().
-
-       PyEval_InitThreads() must not be called concurrently at all.
-       So we use a global variable as a simple spin lock.  This global
-       variable must be from 'libpythonX.Y.so', not from this
-       cffi-based extension module, because it must be shared from
-       different cffi-based extension modules.  We choose
-       _PyParser_TokenNames[0] as a completely arbitrary pointer value
-       that is never written to.  The default is to point to the
-       string "ENDMARKER".  We change it temporarily to point to the
-       next character in that string.  (Yes, I know it's REALLY
-       obscure.)
-
-    Python 3
-    ========
-
-       In Python 3, PyEval_InitThreads() cannot be called before
-       Py_InitializeEx() any more.  So this function calls
-       Py_InitializeEx() first.  It uses the same obscure logic to
-       make sure we never call it concurrently.
-
-       Arguably, this is less good on the spinlock, because
-       Py_InitializeEx() takes much longer to run than
-       PyEval_InitThreads().  But I didn't find a way around it.
-    */
-
-#ifdef WITH_THREAD
-    char *volatile *lock = (char *volatile *)_PyParser_TokenNames;
-    char *old_value;
-
-    while (1) {    /* spin loop */
-        old_value = *lock;
-        if (old_value[0] == 'E') {
-            assert(old_value[1] == 'N');
-            if (cffi_compare_and_swap(lock, old_value, old_value + 1))
-                break;
-        }
-        else {
-            assert(old_value[0] == 'N');
-            /* should ideally do a spin loop instruction here, but
-               hard to do it portably and doesn't really matter I
-               think: PyEval_InitThreads() should be very fast, and
-               this is only run at start-up anyway. */
-        }
-    }
-#endif
-
-#if PY_MAJOR_VERSION >= 3
-    /* Python 3: call Py_InitializeEx() */
-    {
-        PyGILState_STATE state = PyGILState_UNLOCKED;
-        if (!Py_IsInitialized())
-            _cffi_py_initialize();
-        else
-            state = PyGILState_Ensure();
-
-        PyEval_InitThreads();
-        PyGILState_Release(state);
-    }
-#else
-    /* Python 2: call PyEval_InitThreads() */
-# ifdef WITH_THREAD
-    if (!PyEval_ThreadsInitialized()) {
-        PyEval_InitThreads();    /* makes the GIL */
-        PyEval_ReleaseLock();    /* then release it */
-    }
-    /* else: there is already a GIL, but we still needed to do the
-       spinlock dance to make sure that we see it as fully ready */
-# endif
-#endif
-
-#ifdef WITH_THREAD
-    /* release the lock */
-    while (!cffi_compare_and_swap(lock, old_value + 1, old_value))
-        ;
-#endif
-
-    return 0;
-}
-
-/**********  end CPython-specific section  **********/
-
-
-#else
-
-
-/**********  PyPy-specific section  **********/
-
-PyMODINIT_FUNC _CFFI_PYTHON_STARTUP_FUNC(const void *[]);   /* forward */
-
-static struct _cffi_pypy_init_s {
-    const char *name;
-    void (*func)(const void *[]);
-    const char *code;
-} _cffi_pypy_init = {
-    _CFFI_MODULE_NAME,
-    (void(*)(const void *[]))_CFFI_PYTHON_STARTUP_FUNC,
-    _CFFI_PYTHON_STARTUP_CODE,
-};
-
-extern int pypy_carefully_make_gil(const char *);
-extern int pypy_init_embedded_cffi_module(int, struct _cffi_pypy_init_s *);
-
-static int _cffi_carefully_make_gil(void)
-{
-    return pypy_carefully_make_gil(_CFFI_MODULE_NAME);
-}
-
-static int _cffi_initialize_python(void)
-{
-    return pypy_init_embedded_cffi_module(0xB011, &_cffi_pypy_init);
-}
-
-/**********  end PyPy-specific section  **********/
-
-
-#endif
-
-
-#ifdef __GNUC__
-__attribute__((noinline))
-#endif
-static _cffi_call_python_fnptr _cffi_start_python(void)
-{
-    /* Delicate logic to initialize Python.  This function can be
-       called multiple times concurrently, e.g. when the process calls
-       its first ``extern "Python"`` functions in multiple threads at
-       once.  It can also be called recursively, in which case we must
-       ignore it.  We also have to consider what occurs if several
-       different cffi-based extensions reach this code in parallel
-       threads---it is a different copy of the code, then, and we
-       can't have any shared global variable unless it comes from
-       'libpythonX.Y.so'.
-
-       Idea:
-
-       * _cffi_carefully_make_gil(): "carefully" call
-         PyEval_InitThreads() (possibly with Py_InitializeEx() first).
-
-       * then we use a (local) custom lock to make sure that a call to this
-         cffi-based extension will wait if another call to the *same*
-         extension is running the initialization in another thread.
-         It is reentrant, so that a recursive call will not block, but
-         only one from a different thread.
-
-       * then we grab the GIL and (Python 2) we call Py_InitializeEx().
-         At this point, concurrent calls to Py_InitializeEx() are not
-         possible: we have the GIL.
-
-       * do the rest of the specific initialization, which may
-         temporarily release the GIL but not the custom lock.
-         Only release the custom lock when we are done.
-    */
-    static char called = 0;
-
-    if (_cffi_carefully_make_gil() != 0)
-        return NULL;
-
-    _cffi_acquire_reentrant_mutex();
-
-    /* Here the GIL exists, but we don't have it.  We're only protected
-       from concurrency by the reentrant mutex. */
-
-    /* This file only initializes the embedded module once, the first
-       time this is called, even if there are subinterpreters. */
-    if (!called) {
-        called = 1;  /* invoke _cffi_initialize_python() only once,
-                        but don't set '_cffi_call_python' right now,
-                        otherwise concurrent threads won't call
-                        this function at all (we need them to wait) */
-        if (_cffi_initialize_python() == 0) {
-            /* now initialization is finished.  Switch to the fast-path. */
-
-            /* We would like nobody to see the new value of
-               '_cffi_call_python' without also seeing the rest of the
-               data initialized.  However, this is not possible.  But
-               the new value of '_cffi_call_python' is the function
-               'cffi_call_python()' from _cffi_backend.  So:  */
-            cffi_write_barrier();
-            /* ^^^ we put a write barrier here, and a corresponding
-               read barrier at the start of cffi_call_python().  This
-               ensures that after that read barrier, we see everything
-               done here before the write barrier.
-            */
-
-            assert(_cffi_call_python_org != NULL);
-            _cffi_call_python = (_cffi_call_python_fnptr)_cffi_call_python_org;
-        }
-        else {
-            /* initialization failed.  Reset this to NULL, even if it was
-               already set to some other value.  Future calls to
-               _cffi_start_python() are still forced to occur, and will
-               always return NULL from now on. */
-            _cffi_call_python_org = NULL;
-        }
-    }
-
-    _cffi_release_reentrant_mutex();
-
-    return (_cffi_call_python_fnptr)_cffi_call_python_org;
-}
-
-static
-void _cffi_start_and_call_python(struct _cffi_externpy_s *externpy, char *args)
-{
-    _cffi_call_python_fnptr fnptr;
-    int current_err = errno;
-#ifdef _MSC_VER
-    int current_lasterr = GetLastError();
-#endif
-    fnptr = _cffi_start_python();
-    if (fnptr == NULL) {
-        fprintf(stderr, "function %s() called, but initialization code "
-                        "failed.  Returning 0.\n", externpy->name);
-        memset(args, 0, externpy->size_of_result);
-    }
-#ifdef _MSC_VER
-    SetLastError(current_lasterr);
-#endif
-    errno = current_err;
-
-    if (fnptr != NULL)
-        fnptr(externpy, args);
-}
-
-
-/* The cffi_start_python() function makes sure Python is initialized
-   and our cffi module is set up.  It can be called manually from the
-   user C code.  The same effect is obtained automatically from any
-   dll-exported ``extern "Python"`` function.  This function returns
-   -1 if initialization failed, 0 if all is OK.  */
-_CFFI_UNUSED_FN
-static int cffi_start_python(void)
-{
-    if (_cffi_call_python == &_cffi_start_and_call_python) {
-        if (_cffi_start_python() == NULL)
-            return -1;
-    }
-    cffi_read_barrier();
-    return 0;
-}
-
-#undef cffi_compare_and_swap
-#undef cffi_write_barrier
-#undef cffi_read_barrier
-
-#ifdef __cplusplus
-}
-#endif

website/web/Lib/site-packages/cffi/api.py

@@ -1,925 +0,0 @@
-import sys, types
-from .lock import allocate_lock
-from .error import CDefError
-from . import model
-
-try:
-    callable
-except NameError:
-    # Python 3.1
-    from collections import Callable
-    callable = lambda x: isinstance(x, Callable)
-
-try:
-    basestring
-except NameError:
-    # Python 3.x
-    basestring = str
-
-
-
-class FFI(object):
-    r'''
-    The main top-level class that you instantiate once, or once per module.
-
-    Example usage:
-
-        ffi = FFI()
-        ffi.cdef("""
-            int printf(const char *, ...);
-        """)
-
-        C = ffi.dlopen(None)   # standard library
-        -or-
-        C = ffi.verify()  # use a C compiler: verify the decl above is right
-
-        C.printf("hello, %s!\n", ffi.new("char[]", "world"))
-    '''
-
-    def __init__(self, backend=None):
-        """Create an FFI instance.  The 'backend' argument is used to
-        select a non-default backend, mostly for tests.
-        """
-        if backend is None:
-            # You need PyPy (>= 2.0 beta), or a CPython (>= 2.6) with
-            # _cffi_backend.so compiled.
-            import _cffi_backend as backend
-            from . import __version__
-            if backend.__version__ != __version__:
-                # bad version!  Try to be as explicit as possible.
-                if hasattr(backend, '__file__'):
-                    # CPython
-                    raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r.  When we import the top-level '_cffi_backend' extension module, we get version %s, located in %r.  The two versions should be equal; check your installation." % (
-                        __version__, __file__,
-                        backend.__version__, backend.__file__))
-                else:
-                    # PyPy
-                    raise Exception("Version mismatch: this is the 'cffi' package version %s, located in %r.  This interpreter comes with a built-in '_cffi_backend' module, which is version %s.  The two versions should be equal; check your installation." % (
-                        __version__, __file__, backend.__version__))
-            # (If you insist you can also try to pass the option
-            # 'backend=backend_ctypes.CTypesBackend()', but don't
-            # rely on it!  It's probably not going to work well.)
-
-        from . import cparser
-        self._backend = backend
-        self._lock = allocate_lock()
-        self._parser = cparser.Parser()
-        self._cached_btypes = {}
-        self._parsed_types = types.ModuleType('parsed_types').__dict__
-        self._new_types = types.ModuleType('new_types').__dict__
-        self._function_caches = []
-        self._libraries = []
-        self._cdefsources = []
-        self._included_ffis = []
-        self._windows_unicode = None
-        self._init_once_cache = {}
-        self._cdef_version = None
-        self._embedding = None
-        self._typecache = model.get_typecache(backend)
-        if hasattr(backend, 'set_ffi'):
-            backend.set_ffi(self)
-        for name in list(backend.__dict__):
-            if name.startswith('RTLD_'):
-                setattr(self, name, getattr(backend, name))
-        #
-        with self._lock:
-            self.BVoidP = self._get_cached_btype(model.voidp_type)
-            self.BCharA = self._get_cached_btype(model.char_array_type)
-        if isinstance(backend, types.ModuleType):
-            # _cffi_backend: attach these constants to the class
-            if not hasattr(FFI, 'NULL'):
-                FFI.NULL = self.cast(self.BVoidP, 0)
-                FFI.CData, FFI.CType = backend._get_types()
-        else:
-            # ctypes backend: attach these constants to the instance
-            self.NULL = self.cast(self.BVoidP, 0)
-            self.CData, self.CType = backend._get_types()
-        self.buffer = backend.buffer
-
-    def cdef(self, csource, override=False, packed=False):
-        """Parse the given C source.  This registers all declared functions,
-        types, and global variables.  The functions and global variables can
-        then be accessed via either 'ffi.dlopen()' or 'ffi.verify()'.
-        The types can be used in 'ffi.new()' and other functions.
-        If 'packed' is specified as True, all structs declared inside this
-        cdef are packed, i.e. laid out without any field alignment at all.
-        """
-        self._cdef(csource, override=override, packed=packed)
-
-    def embedding_api(self, csource, packed=False):
-        self._cdef(csource, packed=packed, dllexport=True)
-        if self._embedding is None:
-            self._embedding = ''
-
-    def _cdef(self, csource, override=False, **options):
-        if not isinstance(csource, str):    # unicode, on Python 2
-            if not isinstance(csource, basestring):
-                raise TypeError("cdef() argument must be a string")
-            csource = csource.encode('ascii')
-        with self._lock:
-            self._cdef_version = object()
-            self._parser.parse(csource, override=override, **options)
-            self._cdefsources.append(csource)
-            if override:
-                for cache in self._function_caches:
-                    cache.clear()
-            finishlist = self._parser._recomplete
-            if finishlist:
-                self._parser._recomplete = []
-                for tp in finishlist:
-                    tp.finish_backend_type(self, finishlist)
-
-    def dlopen(self, name, flags=0):
-        """Load and return a dynamic library identified by 'name'.
-        The standard C library can be loaded by passing None.
-        Note that functions and types declared by 'ffi.cdef()' are not
-        linked to a particular library, just like C headers; in the
-        library we only look for the actual (untyped) symbols.
-        """
-        assert isinstance(name, basestring) or name is None
-        with self._lock:
-            lib, function_cache = _make_ffi_library(self, name, flags)
-            self._function_caches.append(function_cache)
-            self._libraries.append(lib)
-        return lib
-
-    def _typeof_locked(self, cdecl):
-        # call me with the lock!
-        key = cdecl
-        if key in self._parsed_types:
-            return self._parsed_types[key]
-        #
-        if not isinstance(cdecl, str):    # unicode, on Python 2
-            cdecl = cdecl.encode('ascii')
-        #
-        type = self._parser.parse_type(cdecl)
-        really_a_function_type = type.is_raw_function
-        if really_a_function_type:
-            type = type.as_function_pointer()
-        btype = self._get_cached_btype(type)
-        result = btype, really_a_function_type
-        self._parsed_types[key] = result
-        return result
-
-    def _typeof(self, cdecl, consider_function_as_funcptr=False):
-        # string -> ctype object
-        try:
-            result = self._parsed_types[cdecl]
-        except KeyError:
-            with self._lock:
-                result = self._typeof_locked(cdecl)
-        #
-        btype, really_a_function_type = result
-        if really_a_function_type and not consider_function_as_funcptr:
-            raise CDefError("the type %r is a function type, not a "
-                            "pointer-to-function type" % (cdecl,))
-        return btype
-
-    def typeof(self, cdecl):
-        """Parse the C type given as a string and return the
-        corresponding <ctype> object.
-        It can also be used on 'cdata' instance to get its C type.
-        """
-        if isinstance(cdecl, basestring):
-            return self._typeof(cdecl)
-        if isinstance(cdecl, self.CData):
-            return self._backend.typeof(cdecl)
-        if isinstance(cdecl, types.BuiltinFunctionType):
-            res = _builtin_function_type(cdecl)
-            if res is not None:
-                return res
-        if (isinstance(cdecl, types.FunctionType)
-                and hasattr(cdecl, '_cffi_base_type')):
-            with self._lock:
-                return self._get_cached_btype(cdecl._cffi_base_type)
-        raise TypeError(type(cdecl))
-
-    def sizeof(self, cdecl):
-        """Return the size in bytes of the argument.  It can be a
-        string naming a C type, or a 'cdata' instance.
-        """
-        if isinstance(cdecl, basestring):
-            BType = self._typeof(cdecl)
-            return self._backend.sizeof(BType)
-        else:
-            return self._backend.sizeof(cdecl)
-
-    def alignof(self, cdecl):
-        """Return the natural alignment size in bytes of the C type
-        given as a string.
-        """
-        if isinstance(cdecl, basestring):
-            cdecl = self._typeof(cdecl)
-        return self._backend.alignof(cdecl)
-
-    def offsetof(self, cdecl, *fields_or_indexes):
-        """Return the offset of the named field inside the given
-        structure or array, which must be given as a C type name.
-        You can give several field names in case of nested structures.
-        You can also give numeric values which correspond to array
-        items, in case of an array type.
-        """
-        if isinstance(cdecl, basestring):
-            cdecl = self._typeof(cdecl)
-        return self._typeoffsetof(cdecl, *fields_or_indexes)[1]
-
-    def new(self, cdecl, init=None):
-        """Allocate an instance according to the specified C type and
-        return a pointer to it.  The specified C type must be either a
-        pointer or an array: ``new('X *')`` allocates an X and returns
-        a pointer to it, whereas ``new('X[n]')`` allocates an array of
-        n X'es and returns an array referencing it (which works
-        mostly like a pointer, like in C).  You can also use
-        ``new('X[]', n)`` to allocate an array of a non-constant
-        length n.
-
-        The memory is initialized following the rules of declaring a
-        global variable in C: by default it is zero-initialized, but
-        an explicit initializer can be given which can be used to
-        fill all or part of the memory.
-
-        When the returned <cdata> object goes out of scope, the memory
-        is freed.  In other words the returned <cdata> object has
-        ownership of the value of type 'cdecl' that it points to.  This
-        means that the raw data can be used as long as this object is
-        kept alive, but must not be used for a longer time.  Be careful
-        about that when copying the pointer to the memory somewhere
-        else, e.g. into another structure.
-        """
-        if isinstance(cdecl, basestring):
-            cdecl = self._typeof(cdecl)
-        return self._backend.newp(cdecl, init)
-
-    def new_allocator(self, alloc=None, free=None,
-                      should_clear_after_alloc=True):
-        """Return a new allocator, i.e. a function that behaves like ffi.new()
-        but uses the provided low-level 'alloc' and 'free' functions.
-
-        'alloc' is called with the size as argument.  If it returns NULL, a
-        MemoryError is raised.  'free' is called with the result of 'alloc'
-        as argument.  Both can be either Python function or directly C
-        functions.  If 'free' is None, then no free function is called.
-        If both 'alloc' and 'free' are None, the default is used.
-
-        If 'should_clear_after_alloc' is set to False, then the memory
-        returned by 'alloc' is assumed to be already cleared (or you are
-        fine with garbage); otherwise CFFI will clear it.
-        """
-        compiled_ffi = self._backend.FFI()
-        allocator = compiled_ffi.new_allocator(alloc, free,
-                                               should_clear_after_alloc)
-        def allocate(cdecl, init=None):
-            if isinstance(cdecl, basestring):
-                cdecl = self._typeof(cdecl)
-            return allocator(cdecl, init)
-        return allocate
-
-    def cast(self, cdecl, source):
-        """Similar to a C cast: returns an instance of the named C
-        type initialized with the given 'source'.  The source is
-        casted between integers or pointers of any type.
-        """
-        if isinstance(cdecl, basestring):
-            cdecl = self._typeof(cdecl)
-        return self._backend.cast(cdecl, source)
-
-    def string(self, cdata, maxlen=-1):
-        """Return a Python string (or unicode string) from the 'cdata'.
-        If 'cdata' is a pointer or array of characters or bytes, returns
-        the null-terminated string.  The returned string extends until
-        the first null character, or at most 'maxlen' characters.  If
-        'cdata' is an array then 'maxlen' defaults to its length.
-
-        If 'cdata' is a pointer or array of wchar_t, returns a unicode
-        string following the same rules.
-
-        If 'cdata' is a single character or byte or a wchar_t, returns
-        it as a string or unicode string.
-
-        If 'cdata' is an enum, returns the value of the enumerator as a
-        string, or 'NUMBER' if the value is out of range.
-        """
-        return self._backend.string(cdata, maxlen)
-
-    def unpack(self, cdata, length):
-        """Unpack an array of C data of the given length,
-        returning a Python string/unicode/list.
-
-        If 'cdata' is a pointer to 'char', returns a byte string.
-        It does not stop at the first null.  This is equivalent to:
-        ffi.buffer(cdata, length)[:]
-
-        If 'cdata' is a pointer to 'wchar_t', returns a unicode string.
-        'length' is measured in wchar_t's; it is not the size in bytes.
-
-        If 'cdata' is a pointer to anything else, returns a list of
-        'length' items.  This is a faster equivalent to:
-        [cdata[i] for i in range(length)]
-        """
-        return self._backend.unpack(cdata, length)
-
-   #def buffer(self, cdata, size=-1):
-   #    """Return a read-write buffer object that references the raw C data
-   #    pointed to by the given 'cdata'.  The 'cdata' must be a pointer or
-   #    an array.  Can be passed to functions expecting a buffer, or directly
-   #    manipulated with:
-   #
-   #        buf[:]          get a copy of it in a regular string, or
-   #        buf[idx]        as a single character
-   #        buf[:] = ...
-   #        buf[idx] = ...  change the content
-   #    """
-   #    note that 'buffer' is a type, set on this instance by __init__
-
-    def from_buffer(self, python_buffer):
-        """Return a <cdata 'char[]'> that points to the data of the
-        given Python object, which must support the buffer interface.
-        Note that this is not meant to be used on the built-in types
-        str or unicode (you can build 'char[]' arrays explicitly)
-        but only on objects containing large quantities of raw data
-        in some other format, like 'array.array' or numpy arrays.
-        """
-        return self._backend.from_buffer(self.BCharA, python_buffer)
-
-    def memmove(self, dest, src, n):
-        """ffi.memmove(dest, src, n) copies n bytes of memory from src to dest.
-
-        Like the C function memmove(), the memory areas may overlap;
-        apart from that it behaves like the C function memcpy().
-
-        'src' can be any cdata ptr or array, or any Python buffer object.
-        'dest' can be any cdata ptr or array, or a writable Python buffer
-        object.  The size to copy, 'n', is always measured in bytes.
-
-        Unlike other methods, this one supports all Python buffer including
-        byte strings and bytearrays---but it still does not support
-        non-contiguous buffers.
-        """
-        return self._backend.memmove(dest, src, n)
-
-    def callback(self, cdecl, python_callable=None, error=None, onerror=None):
-        """Return a callback object or a decorator making such a
-        callback object.  'cdecl' must name a C function pointer type.
-        The callback invokes the specified 'python_callable' (which may
-        be provided either directly or via a decorator).  Important: the
-        callback object must be manually kept alive for as long as the
-        callback may be invoked from the C level.
-        """
-        def callback_decorator_wrap(python_callable):
-            if not callable(python_callable):
-                raise TypeError("the 'python_callable' argument "
-                                "is not callable")
-            return self._backend.callback(cdecl, python_callable,
-                                          error, onerror)
-        if isinstance(cdecl, basestring):
-            cdecl = self._typeof(cdecl, consider_function_as_funcptr=True)
-        if python_callable is None:
-            return callback_decorator_wrap                # decorator mode
-        else:
-            return callback_decorator_wrap(python_callable)  # direct mode
-
-    def getctype(self, cdecl, replace_with=''):
-        """Return a string giving the C type 'cdecl', which may be itself
-        a string or a <ctype> object.  If 'replace_with' is given, it gives
-        extra text to append (or insert for more complicated C types), like
-        a variable name, or '*' to get actually the C type 'pointer-to-cdecl'.
-        """
-        if isinstance(cdecl, basestring):
-            cdecl = self._typeof(cdecl)
-        replace_with = replace_with.strip()
-        if (replace_with.startswith('*')
-                and '&[' in self._backend.getcname(cdecl, '&')):
-            replace_with = '(%s)' % replace_with
-        elif replace_with and not replace_with[0] in '[(':
-            replace_with = ' ' + replace_with
-        return self._backend.getcname(cdecl, replace_with)
-
-    def gc(self, cdata, destructor, size=0):
-        """Return a new cdata object that points to the same
-        data.  Later, when this new cdata object is garbage-collected,
-        'destructor(old_cdata_object)' will be called.
-
-        The optional 'size' gives an estimate of the size, used to
-        trigger the garbage collection more eagerly.  So far only used
-        on PyPy.  It tells the GC that the returned object keeps alive
-        roughly 'size' bytes of external memory.
-        """
-        return self._backend.gcp(cdata, destructor, size)
-
-    def _get_cached_btype(self, type):
-        assert self._lock.acquire(False) is False
-        # call me with the lock!
-        try:
-            BType = self._cached_btypes[type]
-        except KeyError:
-            finishlist = []
-            BType = type.get_cached_btype(self, finishlist)
-            for type in finishlist:
-                type.finish_backend_type(self, finishlist)
-        return BType
-
-    def verify(self, source='', tmpdir=None, **kwargs):
-        """Verify that the current ffi signatures compile on this
-        machine, and return a dynamic library object.  The dynamic
-        library can be used to call functions and access global
-        variables declared in this 'ffi'.  The library is compiled
-        by the C compiler: it gives you C-level API compatibility
-        (including calling macros).  This is unlike 'ffi.dlopen()',
-        which requires binary compatibility in the signatures.
-        """
-        from .verifier import Verifier, _caller_dir_pycache
-        #
-        # If set_unicode(True) was called, insert the UNICODE and
-        # _UNICODE macro declarations
-        if self._windows_unicode:
-            self._apply_windows_unicode(kwargs)
-        #
-        # Set the tmpdir here, and not in Verifier.__init__: it picks
-        # up the caller's directory, which we want to be the caller of
-        # ffi.verify(), as opposed to the caller of Veritier().
-        tmpdir = tmpdir or _caller_dir_pycache()
-        #
-        # Make a Verifier() and use it to load the library.
-        self.verifier = Verifier(self, source, tmpdir, **kwargs)
-        lib = self.verifier.load_library()
-        #
-        # Save the loaded library for keep-alive purposes, even
-        # if the caller doesn't keep it alive itself (it should).
-        self._libraries.append(lib)
-        return lib
-
-    def _get_errno(self):
-        return self._backend.get_errno()
-    def _set_errno(self, errno):
-        self._backend.set_errno(errno)
-    errno = property(_get_errno, _set_errno, None,
-                     "the value of 'errno' from/to the C calls")
-
-    def getwinerror(self, code=-1):
-        return self._backend.getwinerror(code)
-
-    def _pointer_to(self, ctype):
-        with self._lock:
-            return model.pointer_cache(self, ctype)
-
-    def addressof(self, cdata, *fields_or_indexes):
-        """Return the address of a <cdata 'struct-or-union'>.
-        If 'fields_or_indexes' are given, returns the address of that
-        field or array item in the structure or array, recursively in
-        case of nested structures.
-        """
-        try:
-            ctype = self._backend.typeof(cdata)
-        except TypeError:
-            if '__addressof__' in type(cdata).__dict__:
-                return type(cdata).__addressof__(cdata, *fields_or_indexes)
-            raise
-        if fields_or_indexes:
-            ctype, offset = self._typeoffsetof(ctype, *fields_or_indexes)
-        else:
-            if ctype.kind == "pointer":
-                raise TypeError("addressof(pointer)")
-            offset = 0
-        ctypeptr = self._pointer_to(ctype)
-        return self._backend.rawaddressof(ctypeptr, cdata, offset)
-
-    def _typeoffsetof(self, ctype, field_or_index, *fields_or_indexes):
-        ctype, offset = self._backend.typeoffsetof(ctype, field_or_index)
-        for field1 in fields_or_indexes:
-            ctype, offset1 = self._backend.typeoffsetof(ctype, field1, 1)
-            offset += offset1
-        return ctype, offset
-
-    def include(self, ffi_to_include):
-        """Includes the typedefs, structs, unions and enums defined
-        in another FFI instance.  Usage is similar to a #include in C,
-        where a part of the program might include types defined in
-        another part for its own usage.  Note that the include()
-        method has no effect on functions, constants and global
-        variables, which must anyway be accessed directly from the
-        lib object returned by the original FFI instance.
-        """
-        if not isinstance(ffi_to_include, FFI):
-            raise TypeError("ffi.include() expects an argument that is also of"
-                            " type cffi.FFI, not %r" % (
-                                type(ffi_to_include).__name__,))
-        if ffi_to_include is self:
-            raise ValueError("self.include(self)")
-        with ffi_to_include._lock:
-            with self._lock:
-                self._parser.include(ffi_to_include._parser)
-                self._cdefsources.append('[')
-                self._cdefsources.extend(ffi_to_include._cdefsources)
-                self._cdefsources.append(']')
-                self._included_ffis.append(ffi_to_include)
-
-    def new_handle(self, x):
-        return self._backend.newp_handle(self.BVoidP, x)
-
-    def from_handle(self, x):
-        return self._backend.from_handle(x)
-
-    def set_unicode(self, enabled_flag):
-        """Windows: if 'enabled_flag' is True, enable the UNICODE and
-        _UNICODE defines in C, and declare the types like TCHAR and LPTCSTR
-        to be (pointers to) wchar_t.  If 'enabled_flag' is False,
-        declare these types to be (pointers to) plain 8-bit characters.
-        This is mostly for backward compatibility; you usually want True.
-        """
-        if self._windows_unicode is not None:
-            raise ValueError("set_unicode() can only be called once")
-        enabled_flag = bool(enabled_flag)
-        if enabled_flag:
-            self.cdef("typedef wchar_t TBYTE;"
-                      "typedef wchar_t TCHAR;"
-                      "typedef const wchar_t *LPCTSTR;"
-                      "typedef const wchar_t *PCTSTR;"
-                      "typedef wchar_t *LPTSTR;"
-                      "typedef wchar_t *PTSTR;"
-                      "typedef TBYTE *PTBYTE;"
-                      "typedef TCHAR *PTCHAR;")
-        else:
-            self.cdef("typedef char TBYTE;"
-                      "typedef char TCHAR;"
-                      "typedef const char *LPCTSTR;"
-                      "typedef const char *PCTSTR;"
-                      "typedef char *LPTSTR;"
-                      "typedef char *PTSTR;"
-                      "typedef TBYTE *PTBYTE;"
-                      "typedef TCHAR *PTCHAR;")
-        self._windows_unicode = enabled_flag
-
-    def _apply_windows_unicode(self, kwds):
-        defmacros = kwds.get('define_macros', ())
-        if not isinstance(defmacros, (list, tuple)):
-            raise TypeError("'define_macros' must be a list or tuple")
-        defmacros = list(defmacros) + [('UNICODE', '1'),
-                                       ('_UNICODE', '1')]
-        kwds['define_macros'] = defmacros
-
-    def _apply_embedding_fix(self, kwds):
-        # must include an argument like "-lpython2.7" for the compiler
-        def ensure(key, value):
-            lst = kwds.setdefault(key, [])
-            if value not in lst:
-                lst.append(value)
-        #
-        if '__pypy__' in sys.builtin_module_names:
-            import os
-            if sys.platform == "win32":
-                # we need 'libpypy-c.lib'.  Current distributions of
-                # pypy (>= 4.1) contain it as 'libs/python27.lib'.
-                pythonlib = "python27"
-                if hasattr(sys, 'prefix'):
-                    ensure('library_dirs', os.path.join(sys.prefix, 'libs'))
-            else:
-                # we need 'libpypy-c.{so,dylib}', which should be by
-                # default located in 'sys.prefix/bin' for installed
-                # systems.
-                if sys.version_info < (3,):
-                    pythonlib = "pypy-c"
-                else:
-                    pythonlib = "pypy3-c"
-                if hasattr(sys, 'prefix'):
-                    ensure('library_dirs', os.path.join(sys.prefix, 'bin'))
-            # On uninstalled pypy's, the libpypy-c is typically found in
-            # .../pypy/goal/.
-            if hasattr(sys, 'prefix'):
-                ensure('library_dirs', os.path.join(sys.prefix, 'pypy', 'goal'))
-        else:
-            if sys.platform == "win32":
-                template = "python%d%d"
-                if hasattr(sys, 'gettotalrefcount'):
-                    template += '_d'
-            else:
-                try:
-                    import sysconfig
-                except ImportError:    # 2.6
-                    from distutils import sysconfig
-                template = "python%d.%d"
-                if sysconfig.get_config_var('DEBUG_EXT'):
-                    template += sysconfig.get_config_var('DEBUG_EXT')
-            pythonlib = (template %
-                    (sys.hexversion >> 24, (sys.hexversion >> 16) & 0xff))
-            if hasattr(sys, 'abiflags'):
-                pythonlib += sys.abiflags
-        ensure('libraries', pythonlib)
-        if sys.platform == "win32":
-            ensure('extra_link_args', '/MANIFEST')
-
-    def set_source(self, module_name, source, source_extension='.c', **kwds):
-        import os
-        if hasattr(self, '_assigned_source'):
-            raise ValueError("set_source() cannot be called several times "
-                             "per ffi object")
-        if not isinstance(module_name, basestring):
-            raise TypeError("'module_name' must be a string")
-        if os.sep in module_name or (os.altsep and os.altsep in module_name):
-            raise ValueError("'module_name' must not contain '/': use a dotted "
-                             "name to make a 'package.module' location")
-        self._assigned_source = (str(module_name), source,
-                                 source_extension, kwds)
-
-    def distutils_extension(self, tmpdir='build', verbose=True):
-        from distutils.dir_util import mkpath
-        from .recompiler import recompile
-        #
-        if not hasattr(self, '_assigned_source'):
-            if hasattr(self, 'verifier'):     # fallback, 'tmpdir' ignored
-                return self.verifier.get_extension()
-            raise ValueError("set_source() must be called before"
-                             " distutils_extension()")
-        module_name, source, source_extension, kwds = self._assigned_source
-        if source is None:
-            raise TypeError("distutils_extension() is only for C extension "
-                            "modules, not for dlopen()-style pure Python "
-                            "modules")
-        mkpath(tmpdir)
-        ext, updated = recompile(self, module_name,
-                                 source, tmpdir=tmpdir, extradir=tmpdir,
-                                 source_extension=source_extension,
-                                 call_c_compiler=False, **kwds)
-        if verbose:
-            if updated:
-                sys.stderr.write("regenerated: %r\n" % (ext.sources[0],))
-            else:
-                sys.stderr.write("not modified: %r\n" % (ext.sources[0],))
-        return ext
-
-    def emit_c_code(self, filename):
-        from .recompiler import recompile
-        #
-        if not hasattr(self, '_assigned_source'):
-            raise ValueError("set_source() must be called before emit_c_code()")
-        module_name, source, source_extension, kwds = self._assigned_source
-        if source is None:
-            raise TypeError("emit_c_code() is only for C extension modules, "
-                            "not for dlopen()-style pure Python modules")
-        recompile(self, module_name, source,
-                  c_file=filename, call_c_compiler=False, **kwds)
-
-    def emit_python_code(self, filename):
-        from .recompiler import recompile
-        #
-        if not hasattr(self, '_assigned_source'):
-            raise ValueError("set_source() must be called before emit_c_code()")
-        module_name, source, source_extension, kwds = self._assigned_source
-        if source is not None:
-            raise TypeError("emit_python_code() is only for dlopen()-style "
-                            "pure Python modules, not for C extension modules")
-        recompile(self, module_name, source,
-                  c_file=filename, call_c_compiler=False, **kwds)
-
-    def compile(self, tmpdir='.', verbose=0, target=None, debug=None):
-        """The 'target' argument gives the final file name of the
-        compiled DLL.  Use '*' to force distutils' choice, suitable for
-        regular CPython C API modules.  Use a file name ending in '.*'
-        to ask for the system's default extension for dynamic libraries
-        (.so/.dll/.dylib).
-
-        The default is '*' when building a non-embedded C API extension,
-        and (module_name + '.*') when building an embedded library.
-        """
-        from .recompiler import recompile
-        #
-        if not hasattr(self, '_assigned_source'):
-            raise ValueError("set_source() must be called before compile()")
-        module_name, source, source_extension, kwds = self._assigned_source
-        return recompile(self, module_name, source, tmpdir=tmpdir,
-                         target=target, source_extension=source_extension,
-                         compiler_verbose=verbose, debug=debug, **kwds)
-
-    def init_once(self, func, tag):
-        # Read _init_once_cache[tag], which is either (False, lock) if
-        # we're calling the function now in some thread, or (True, result).
-        # Don't call setdefault() in most cases, to avoid allocating and
-        # immediately freeing a lock; but still use setdefaut() to avoid
-        # races.
-        try:
-            x = self._init_once_cache[tag]
-        except KeyError:
-            x = self._init_once_cache.setdefault(tag, (False, allocate_lock()))
-        # Common case: we got (True, result), so we return the result.
-        if x[0]:
-            return x[1]
-        # Else, it's a lock.  Acquire it to serialize the following tests.
-        with x[1]:
-            # Read again from _init_once_cache the current status.
-            x = self._init_once_cache[tag]
-            if x[0]:
-                return x[1]
-            # Call the function and store the result back.
-            result = func()
-            self._init_once_cache[tag] = (True, result)
-        return result
-
-    def embedding_init_code(self, pysource):
-        if self._embedding:
-            raise ValueError("embedding_init_code() can only be called once")
-        # fix 'pysource' before it gets dumped into the C file:
-        # - remove empty lines at the beginning, so it starts at "line 1"
-        # - dedent, if all non-empty lines are indented
-        # - check for SyntaxErrors
-        import re
-        match = re.match(r'\s*\n', pysource)
-        if match:
-            pysource = pysource[match.end():]
-        lines = pysource.splitlines() or ['']
-        prefix = re.match(r'\s*', lines[0]).group()
-        for i in range(1, len(lines)):
-            line = lines[i]
-            if line.rstrip():
-                while not line.startswith(prefix):
-                    prefix = prefix[:-1]
-        i = len(prefix)
-        lines = [line[i:]+'\n' for line in lines]
-        pysource = ''.join(lines)
-        #
-        compile(pysource, "cffi_init", "exec")
-        #
-        self._embedding = pysource
-
-    def def_extern(self, *args, **kwds):
-        raise ValueError("ffi.def_extern() is only available on API-mode FFI "
-                         "objects")
-
-    def list_types(self):
-        """Returns the user type names known to this FFI instance.
-        This returns a tuple containing three lists of names:
-        (typedef_names, names_of_structs, names_of_unions)
-        """
-        typedefs = []
-        structs = []
-        unions = []
-        for key in self._parser._declarations:
-            if key.startswith('typedef '):
-                typedefs.append(key[8:])
-            elif key.startswith('struct '):
-                structs.append(key[7:])
-            elif key.startswith('union '):
-                unions.append(key[6:])
-        typedefs.sort()
-        structs.sort()
-        unions.sort()
-        return (typedefs, structs, unions)
-
-
-def _load_backend_lib(backend, name, flags):
-    import os
-    if name is None:
-        if sys.platform != "win32":
-            return backend.load_library(None, flags)
-        name = "c"    # Windows: load_library(None) fails, but this works
-                      # on Python 2 (backward compatibility hack only)
-    first_error = None
-    if '.' in name or '/' in name or os.sep in name:
-        try:
-            return backend.load_library(name, flags)
-        except OSError as e:
-            first_error = e
-    import ctypes.util
-    path = ctypes.util.find_library(name)
-    if path is None:
-        if name == "c" and sys.platform == "win32" and sys.version_info >= (3,):
-            raise OSError("dlopen(None) cannot work on Windows for Python 3 "
-                          "(see http://bugs.python.org/issue23606)")
-        msg = ("ctypes.util.find_library() did not manage "
-               "to locate a library called %r" % (name,))
-        if first_error is not None:
-            msg = "%s.  Additionally, %s" % (first_error, msg)
-        raise OSError(msg)
-    return backend.load_library(path, flags)
-
-def _make_ffi_library(ffi, libname, flags):
-    backend = ffi._backend
-    backendlib = _load_backend_lib(backend, libname, flags)
-    #
-    def accessor_function(name):
-        key = 'function ' + name
-        tp, _ = ffi._parser._declarations[key]
-        BType = ffi._get_cached_btype(tp)
-        value = backendlib.load_function(BType, name)
-        library.__dict__[name] = value
-    #
-    def accessor_variable(name):
-        key = 'variable ' + name
-        tp, _ = ffi._parser._declarations[key]
-        BType = ffi._get_cached_btype(tp)
-        read_variable = backendlib.read_variable
-        write_variable = backendlib.write_variable
-        setattr(FFILibrary, name, property(
-            lambda self: read_variable(BType, name),
-            lambda self, value: write_variable(BType, name, value)))
-    #
-    def addressof_var(name):
-        try:
-            return addr_variables[name]
-        except KeyError:
-            with ffi._lock:
-                if name not in addr_variables:
-                    key = 'variable ' + name
-                    tp, _ = ffi._parser._declarations[key]
-                    BType = ffi._get_cached_btype(tp)
-                    if BType.kind != 'array':
-                        BType = model.pointer_cache(ffi, BType)
-                    p = backendlib.load_function(BType, name)
-                    addr_variables[name] = p
-            return addr_variables[name]
-    #
-    def accessor_constant(name):
-        raise NotImplementedError("non-integer constant '%s' cannot be "
-                                  "accessed from a dlopen() library" % (name,))
-    #
-    def accessor_int_constant(name):
-        library.__dict__[name] = ffi._parser._int_constants[name]
-    #
-    accessors = {}
-    accessors_version = [False]
-    addr_variables = {}
-    #
-    def update_accessors():
-        if accessors_version[0] is ffi._cdef_version:
-            return
-        #
-        for key, (tp, _) in ffi._parser._declarations.items():
-            if not isinstance(tp, model.EnumType):
-                tag, name = key.split(' ', 1)
-                if tag == 'function':
-                    accessors[name] = accessor_function
-                elif tag == 'variable':
-                    accessors[name] = accessor_variable
-                elif tag == 'constant':
-                    accessors[name] = accessor_constant
-            else:
-                for i, enumname in enumerate(tp.enumerators):
-                    def accessor_enum(name, tp=tp, i=i):
-                        tp.check_not_partial()
-                        library.__dict__[name] = tp.enumvalues[i]
-                    accessors[enumname] = accessor_enum
-        for name in ffi._parser._int_constants:
-            accessors.setdefault(name, accessor_int_constant)
-        accessors_version[0] = ffi._cdef_version
-    #
-    def make_accessor(name):
-        with ffi._lock:
-            if name in library.__dict__ or name in FFILibrary.__dict__:
-                return    # added by another thread while waiting for the lock
-            if name not in accessors:
-                update_accessors()
-                if name not in accessors:
-                    raise AttributeError(name)
-            accessors[name](name)
-    #
-    class FFILibrary(object):
-        def __getattr__(self, name):
-            make_accessor(name)
-            return getattr(self, name)
-        def __setattr__(self, name, value):
-            try:
-                property = getattr(self.__class__, name)
-            except AttributeError:
-                make_accessor(name)
-                setattr(self, name, value)
-            else:
-                property.__set__(self, value)
-        def __dir__(self):
-            with ffi._lock:
-                update_accessors()
-                return accessors.keys()
-        def __addressof__(self, name):
-            if name in library.__dict__:
-                return library.__dict__[name]
-            if name in FFILibrary.__dict__:
-                return addressof_var(name)
-            make_accessor(name)
-            if name in library.__dict__:
-                return library.__dict__[name]
-            if name in FFILibrary.__dict__:
-                return addressof_var(name)
-            raise AttributeError("cffi library has no function or "
-                                 "global variable named '%s'" % (name,))
-    #
-    if libname is not None:
-        try:
-            if not isinstance(libname, str):    # unicode, on Python 2
-                libname = libname.encode('utf-8')
-            FFILibrary.__name__ = 'FFILibrary_%s' % libname
-        except UnicodeError:
-            pass
-    library = FFILibrary()
-    return library, library.__dict__
-
-def _builtin_function_type(func):
-    # a hack to make at least ffi.typeof(builtin_function) work,
-    # if the builtin function was obtained by 'vengine_cpy'.
-    import sys
-    try:
-        module = sys.modules[func.__module__]
-        ffi = module._cffi_original_ffi
-        types_of_builtin_funcs = module._cffi_types_of_builtin_funcs
-        tp = types_of_builtin_funcs[func]
-    except (KeyError, AttributeError, TypeError):
-        return None
-    else:
-        with ffi._lock:
-            return ffi._get_cached_btype(tp)

website/web/Lib/site-packages/cffi/cffi_opcode.py

@@ -1,187 +0,0 @@
-from .error import VerificationError
-
-class CffiOp(object):
-    def __init__(self, op, arg):
-        self.op = op
-        self.arg = arg
-
-    def as_c_expr(self):
-        if self.op is None:
-            assert isinstance(self.arg, str)
-            return '(_cffi_opcode_t)(%s)' % (self.arg,)
-        classname = CLASS_NAME[self.op]
-        return '_CFFI_OP(_CFFI_OP_%s, %s)' % (classname, self.arg)
-
-    def as_python_bytes(self):
-        if self.op is None and self.arg.isdigit():
-            value = int(self.arg)     # non-negative: '-' not in self.arg
-            if value >= 2**31:
-                raise OverflowError("cannot emit %r: limited to 2**31-1"
-                                    % (self.arg,))
-            return format_four_bytes(value)
-        if isinstance(self.arg, str):
-            raise VerificationError("cannot emit to Python: %r" % (self.arg,))
-        return format_four_bytes((self.arg << 8) | self.op)
-
-    def __str__(self):
-        classname = CLASS_NAME.get(self.op, self.op)
-        return '(%s %s)' % (classname, self.arg)
-
-def format_four_bytes(num):
-    return '\\x%02X\\x%02X\\x%02X\\x%02X' % (
-        (num >> 24) & 0xFF,
-        (num >> 16) & 0xFF,
-        (num >>  8) & 0xFF,
-        (num      ) & 0xFF)
-
-OP_PRIMITIVE       = 1
-OP_POINTER         = 3
-OP_ARRAY           = 5
-OP_OPEN_ARRAY      = 7
-OP_STRUCT_UNION    = 9
-OP_ENUM            = 11
-OP_FUNCTION        = 13
-OP_FUNCTION_END    = 15
-OP_NOOP            = 17
-OP_BITFIELD        = 19
-OP_TYPENAME        = 21
-OP_CPYTHON_BLTN_V  = 23   # varargs
-OP_CPYTHON_BLTN_N  = 25   # noargs
-OP_CPYTHON_BLTN_O  = 27   # O  (i.e. a single arg)
-OP_CONSTANT        = 29
-OP_CONSTANT_INT    = 31
-OP_GLOBAL_VAR      = 33
-OP_DLOPEN_FUNC     = 35
-OP_DLOPEN_CONST    = 37
-OP_GLOBAL_VAR_F    = 39
-OP_EXTERN_PYTHON   = 41
-
-PRIM_VOID          = 0
-PRIM_BOOL          = 1
-PRIM_CHAR          = 2
-PRIM_SCHAR         = 3
-PRIM_UCHAR         = 4
-PRIM_SHORT         = 5
-PRIM_USHORT        = 6
-PRIM_INT           = 7
-PRIM_UINT          = 8
-PRIM_LONG          = 9
-PRIM_ULONG         = 10
-PRIM_LONGLONG      = 11
-PRIM_ULONGLONG     = 12
-PRIM_FLOAT         = 13
-PRIM_DOUBLE        = 14
-PRIM_LONGDOUBLE    = 15
-
-PRIM_WCHAR         = 16
-PRIM_INT8          = 17
-PRIM_UINT8         = 18
-PRIM_INT16         = 19
-PRIM_UINT16        = 20
-PRIM_INT32         = 21
-PRIM_UINT32        = 22
-PRIM_INT64         = 23
-PRIM_UINT64        = 24
-PRIM_INTPTR        = 25
-PRIM_UINTPTR       = 26
-PRIM_PTRDIFF       = 27
-PRIM_SIZE          = 28
-PRIM_SSIZE         = 29
-PRIM_INT_LEAST8    = 30
-PRIM_UINT_LEAST8   = 31
-PRIM_INT_LEAST16   = 32
-PRIM_UINT_LEAST16  = 33
-PRIM_INT_LEAST32   = 34
-PRIM_UINT_LEAST32  = 35
-PRIM_INT_LEAST64   = 36
-PRIM_UINT_LEAST64  = 37
-PRIM_INT_FAST8     = 38
-PRIM_UINT_FAST8    = 39
-PRIM_INT_FAST16    = 40
-PRIM_UINT_FAST16   = 41
-PRIM_INT_FAST32    = 42
-PRIM_UINT_FAST32   = 43
-PRIM_INT_FAST64    = 44
-PRIM_UINT_FAST64   = 45
-PRIM_INTMAX        = 46
-PRIM_UINTMAX       = 47
-PRIM_FLOATCOMPLEX  = 48
-PRIM_DOUBLECOMPLEX = 49
-PRIM_CHAR16        = 50
-PRIM_CHAR32        = 51
-
-_NUM_PRIM          = 52
-_UNKNOWN_PRIM          = -1
-_UNKNOWN_FLOAT_PRIM    = -2
-_UNKNOWN_LONG_DOUBLE   = -3
-
-_IO_FILE_STRUCT        = -1
-
-PRIMITIVE_TO_INDEX = {
-    'char':               PRIM_CHAR,
-    'short':              PRIM_SHORT,
-    'int':                PRIM_INT,
-    'long':               PRIM_LONG,
-    'long long':          PRIM_LONGLONG,
-    'signed char':        PRIM_SCHAR,
-    'unsigned char':      PRIM_UCHAR,
-    'unsigned short':     PRIM_USHORT,
-    'unsigned int':       PRIM_UINT,
-    'unsigned long':      PRIM_ULONG,
-    'unsigned long long': PRIM_ULONGLONG,
-    'float':              PRIM_FLOAT,
-    'double':             PRIM_DOUBLE,
-    'long double':        PRIM_LONGDOUBLE,
-    'float _Complex':     PRIM_FLOATCOMPLEX,
-    'double _Complex':    PRIM_DOUBLECOMPLEX,
-    '_Bool':              PRIM_BOOL,
-    'wchar_t':            PRIM_WCHAR,
-    'char16_t':           PRIM_CHAR16,
-    'char32_t':           PRIM_CHAR32,
-    'int8_t':             PRIM_INT8,
-    'uint8_t':            PRIM_UINT8,
-    'int16_t':            PRIM_INT16,
-    'uint16_t':           PRIM_UINT16,
-    'int32_t':            PRIM_INT32,
-    'uint32_t':           PRIM_UINT32,
-    'int64_t':            PRIM_INT64,
-    'uint64_t':           PRIM_UINT64,
-    'intptr_t':           PRIM_INTPTR,
-    'uintptr_t':          PRIM_UINTPTR,
-    'ptrdiff_t':          PRIM_PTRDIFF,
-    'size_t':             PRIM_SIZE,
-    'ssize_t':            PRIM_SSIZE,
-    'int_least8_t':       PRIM_INT_LEAST8,
-    'uint_least8_t':      PRIM_UINT_LEAST8,
-    'int_least16_t':      PRIM_INT_LEAST16,
-    'uint_least16_t':     PRIM_UINT_LEAST16,
-    'int_least32_t':      PRIM_INT_LEAST32,
-    'uint_least32_t':     PRIM_UINT_LEAST32,
-    'int_least64_t':      PRIM_INT_LEAST64,
-    'uint_least64_t':     PRIM_UINT_LEAST64,
-    'int_fast8_t':        PRIM_INT_FAST8,
-    'uint_fast8_t':       PRIM_UINT_FAST8,
-    'int_fast16_t':       PRIM_INT_FAST16,
-    'uint_fast16_t':      PRIM_UINT_FAST16,
-    'int_fast32_t':       PRIM_INT_FAST32,
-    'uint_fast32_t':      PRIM_UINT_FAST32,
-    'int_fast64_t':       PRIM_INT_FAST64,
-    'uint_fast64_t':      PRIM_UINT_FAST64,
-    'intmax_t':           PRIM_INTMAX,
-    'uintmax_t':          PRIM_UINTMAX,
-    }
-
-F_UNION         = 0x01
-F_CHECK_FIELDS  = 0x02
-F_PACKED        = 0x04
-F_EXTERNAL      = 0x08
-F_OPAQUE        = 0x10
-
-G_FLAGS = dict([('_CFFI_' + _key, globals()[_key])
-                for _key in ['F_UNION', 'F_CHECK_FIELDS', 'F_PACKED',
-                             'F_EXTERNAL', 'F_OPAQUE']])
-
-CLASS_NAME = {}
-for _name, _value in list(globals().items()):
-    if _name.startswith('OP_') and isinstance(_value, int):
-        CLASS_NAME[_value] = _name[3:]

website/web/Lib/site-packages/cffi/commontypes.py

@@ -1,80 +0,0 @@
-import sys
-from . import model
-from .error import FFIError
-
-
-COMMON_TYPES = {}
-
-try:
-    # fetch "bool" and all simple Windows types
-    from _cffi_backend import _get_common_types
-    _get_common_types(COMMON_TYPES)
-except ImportError:
-    pass
-
-COMMON_TYPES['FILE'] = model.unknown_type('FILE', '_IO_FILE')
-COMMON_TYPES['bool'] = '_Bool'    # in case we got ImportError above
-
-for _type in model.PrimitiveType.ALL_PRIMITIVE_TYPES:
-    if _type.endswith('_t'):
-        COMMON_TYPES[_type] = _type
-del _type
-
-_CACHE = {}
-
-def resolve_common_type(parser, commontype):
-    try:
-        return _CACHE[commontype]
-    except KeyError:
-        cdecl = COMMON_TYPES.get(commontype, commontype)
-        if not isinstance(cdecl, str):
-            result, quals = cdecl, 0    # cdecl is already a BaseType
-        elif cdecl in model.PrimitiveType.ALL_PRIMITIVE_TYPES:
-            result, quals = model.PrimitiveType(cdecl), 0
-        elif cdecl == 'set-unicode-needed':
-            raise FFIError("The Windows type %r is only available after "
-                           "you call ffi.set_unicode()" % (commontype,))
-        else:
-            if commontype == cdecl:
-                raise FFIError(
-                    "Unsupported type: %r.  Please look at "
-        "http://cffi.readthedocs.io/en/latest/cdef.html#ffi-cdef-limitations "
-                    "and file an issue if you think this type should really "
-                    "be supported." % (commontype,))
-            result, quals = parser.parse_type_and_quals(cdecl)   # recursive
-
-        assert isinstance(result, model.BaseTypeByIdentity)
-        _CACHE[commontype] = result, quals
-        return result, quals
-
-
-# ____________________________________________________________
-# extra types for Windows (most of them are in commontypes.c)
-
-
-def win_common_types():
-    return {
-        "UNICODE_STRING": model.StructType(
-            "_UNICODE_STRING",
-            ["Length",
-             "MaximumLength",
-             "Buffer"],
-            [model.PrimitiveType("unsigned short"),
-             model.PrimitiveType("unsigned short"),
-             model.PointerType(model.PrimitiveType("wchar_t"))],
-            [-1, -1, -1]),
-        "PUNICODE_STRING": "UNICODE_STRING *",
-        "PCUNICODE_STRING": "const UNICODE_STRING *",
-
-        "TBYTE": "set-unicode-needed",
-        "TCHAR": "set-unicode-needed",
-        "LPCTSTR": "set-unicode-needed",
-        "PCTSTR": "set-unicode-needed",
-        "LPTSTR": "set-unicode-needed",
-        "PTSTR": "set-unicode-needed",
-        "PTBYTE": "set-unicode-needed",
-        "PTCHAR": "set-unicode-needed",
-        }
-
-if sys.platform == 'win32':
-    COMMON_TYPES.update(win_common_types())

website/web/Lib/site-packages/cffi/cparser.py

@@ -1,891 +0,0 @@
-from . import model
-from .commontypes import COMMON_TYPES, resolve_common_type
-from .error import FFIError, CDefError
-try:
-    from . import _pycparser as pycparser
-except ImportError:
-    import pycparser
-import weakref, re, sys
-
-try:
-    if sys.version_info < (3,):
-        import thread as _thread
-    else:
-        import _thread
-    lock = _thread.allocate_lock()
-except ImportError:
-    lock = None
-
-CDEF_SOURCE_STRING = "<cdef source string>"
-_r_comment = re.compile(r"/\*.*?\*/|//([^\n\\]|\\.)*?$",
-                        re.DOTALL | re.MULTILINE)
-_r_define  = re.compile(r"^\s*#\s*define\s+([A-Za-z_][A-Za-z_0-9]*)"
-                        r"\b((?:[^\n\\]|\\.)*?)$",
-                        re.DOTALL | re.MULTILINE)
-_r_partial_enum = re.compile(r"=\s*\.\.\.\s*[,}]|\.\.\.\s*\}")
-_r_enum_dotdotdot = re.compile(r"__dotdotdot\d+__$")
-_r_partial_array = re.compile(r"\[\s*\.\.\.\s*\]")
-_r_words = re.compile(r"\w+|\S")
-_parser_cache = None
-_r_int_literal = re.compile(r"-?0?x?[0-9a-f]+[lu]*$", re.IGNORECASE)
-_r_stdcall1 = re.compile(r"\b(__stdcall|WINAPI)\b")
-_r_stdcall2 = re.compile(r"[(]\s*(__stdcall|WINAPI)\b")
-_r_cdecl = re.compile(r"\b__cdecl\b")
-_r_extern_python = re.compile(r'\bextern\s*"'
-                              r'(Python|Python\s*\+\s*C|C\s*\+\s*Python)"\s*.')
-_r_star_const_space = re.compile(       # matches "* const "
-    r"[*]\s*((const|volatile|restrict)\b\s*)+")
-_r_int_dotdotdot = re.compile(r"(\b(int|long|short|signed|unsigned|char)\s*)+"
-                              r"\.\.\.")
-_r_float_dotdotdot = re.compile(r"\b(double|float)\s*\.\.\.")
-
-def _get_parser():
-    global _parser_cache
-    if _parser_cache is None:
-        _parser_cache = pycparser.CParser()
-    return _parser_cache
-
-def _workaround_for_old_pycparser(csource):
-    # Workaround for a pycparser issue (fixed between pycparser 2.10 and
-    # 2.14): "char*const***" gives us a wrong syntax tree, the same as
-    # for "char***(*const)".  This means we can't tell the difference
-    # afterwards.  But "char(*const(***))" gives us the right syntax
-    # tree.  The issue only occurs if there are several stars in
-    # sequence with no parenthesis inbetween, just possibly qualifiers.
-    # Attempt to fix it by adding some parentheses in the source: each
-    # time we see "* const" or "* const *", we add an opening
-    # parenthesis before each star---the hard part is figuring out where
-    # to close them.
-    parts = []
-    while True:
-        match = _r_star_const_space.search(csource)
-        if not match:
-            break
-        #print repr(''.join(parts)+csource), '=>',
-        parts.append(csource[:match.start()])
-        parts.append('('); closing = ')'
-        parts.append(match.group())   # e.g. "* const "
-        endpos = match.end()
-        if csource.startswith('*', endpos):
-            parts.append('('); closing += ')'
-        level = 0
-        i = endpos
-        while i < len(csource):
-            c = csource[i]
-            if c == '(':
-                level += 1
-            elif c == ')':
-                if level == 0:
-                    break
-                level -= 1
-            elif c in ',;=':
-                if level == 0:
-                    break
-            i += 1
-        csource = csource[endpos:i] + closing + csource[i:]
-        #print repr(''.join(parts)+csource)
-    parts.append(csource)
-    return ''.join(parts)
-
-def _preprocess_extern_python(csource):
-    # input: `extern "Python" int foo(int);` or
-    #        `extern "Python" { int foo(int); }`
-    # output:
-    #     void __cffi_extern_python_start;
-    #     int foo(int);
-    #     void __cffi_extern_python_stop;
-    #
-    # input: `extern "Python+C" int foo(int);`
-    # output:
-    #     void __cffi_extern_python_plus_c_start;
-    #     int foo(int);
-    #     void __cffi_extern_python_stop;
-    parts = []
-    while True:
-        match = _r_extern_python.search(csource)
-        if not match:
-            break
-        endpos = match.end() - 1
-        #print
-        #print ''.join(parts)+csource
-        #print '=>'
-        parts.append(csource[:match.start()])
-        if 'C' in match.group(1):
-            parts.append('void __cffi_extern_python_plus_c_start; ')
-        else:
-            parts.append('void __cffi_extern_python_start; ')
-        if csource[endpos] == '{':
-            # grouping variant
-            closing = csource.find('}', endpos)
-            if closing < 0:
-                raise CDefError("'extern \"Python\" {': no '}' found")
-            if csource.find('{', endpos + 1, closing) >= 0:
-                raise NotImplementedError("cannot use { } inside a block "
-                                          "'extern \"Python\" { ... }'")
-            parts.append(csource[endpos+1:closing])
-            csource = csource[closing+1:]
-        else:
-            # non-grouping variant
-            semicolon = csource.find(';', endpos)
-            if semicolon < 0:
-                raise CDefError("'extern \"Python\": no ';' found")
-            parts.append(csource[endpos:semicolon+1])
-            csource = csource[semicolon+1:]
-        parts.append(' void __cffi_extern_python_stop;')
-        #print ''.join(parts)+csource
-        #print
-    parts.append(csource)
-    return ''.join(parts)
-
-def _preprocess(csource):
-    # Remove comments.  NOTE: this only work because the cdef() section
-    # should not contain any string literal!
-    csource = _r_comment.sub(' ', csource)
-    # Remove the "#define FOO x" lines
-    macros = {}
-    for match in _r_define.finditer(csource):
-        macroname, macrovalue = match.groups()
-        macrovalue = macrovalue.replace('\\\n', '').strip()
-        macros[macroname] = macrovalue
-    csource = _r_define.sub('', csource)
-    #
-    if pycparser.__version__ < '2.14':
-        csource = _workaround_for_old_pycparser(csource)
-    #
-    # BIG HACK: replace WINAPI or __stdcall with "volatile const".
-    # It doesn't make sense for the return type of a function to be
-    # "volatile volatile const", so we abuse it to detect __stdcall...
-    # Hack number 2 is that "int(volatile *fptr)();" is not valid C
-    # syntax, so we place the "volatile" before the opening parenthesis.
-    csource = _r_stdcall2.sub(' volatile volatile const(', csource)
-    csource = _r_stdcall1.sub(' volatile volatile const ', csource)
-    csource = _r_cdecl.sub(' ', csource)
-    #
-    # Replace `extern "Python"` with start/end markers
-    csource = _preprocess_extern_python(csource)
-    #
-    # Replace "[...]" with "[__dotdotdotarray__]"
-    csource = _r_partial_array.sub('[__dotdotdotarray__]', csource)
-    #
-    # Replace "...}" with "__dotdotdotNUM__}".  This construction should
-    # occur only at the end of enums; at the end of structs we have "...;}"
-    # and at the end of vararg functions "...);".  Also replace "=...[,}]"
-    # with ",__dotdotdotNUM__[,}]": this occurs in the enums too, when
-    # giving an unknown value.
-    matches = list(_r_partial_enum.finditer(csource))
-    for number, match in enumerate(reversed(matches)):
-        p = match.start()
-        if csource[p] == '=':
-            p2 = csource.find('...', p, match.end())
-            assert p2 > p
-            csource = '%s,__dotdotdot%d__ %s' % (csource[:p], number,
-                                                 csource[p2+3:])
-        else:
-            assert csource[p:p+3] == '...'
-            csource = '%s __dotdotdot%d__ %s' % (csource[:p], number,
-                                                 csource[p+3:])
-    # Replace "int ..." or "unsigned long int..." with "__dotdotdotint__"
-    csource = _r_int_dotdotdot.sub(' __dotdotdotint__ ', csource)
-    # Replace "float ..." or "double..." with "__dotdotdotfloat__"
-    csource = _r_float_dotdotdot.sub(' __dotdotdotfloat__ ', csource)
-    # Replace all remaining "..." with the same name, "__dotdotdot__",
-    # which is declared with a typedef for the purpose of C parsing.
-    return csource.replace('...', ' __dotdotdot__ '), macros
-
-def _common_type_names(csource):
-    # Look in the source for what looks like usages of types from the
-    # list of common types.  A "usage" is approximated here as the
-    # appearance of the word, minus a "definition" of the type, which
-    # is the last word in a "typedef" statement.  Approximative only
-    # but should be fine for all the common types.
-    look_for_words = set(COMMON_TYPES)
-    look_for_words.add(';')
-    look_for_words.add(',')
-    look_for_words.add('(')
-    look_for_words.add(')')
-    look_for_words.add('typedef')
-    words_used = set()
-    is_typedef = False
-    paren = 0
-    previous_word = ''
-    for word in _r_words.findall(csource):
-        if word in look_for_words:
-            if word == ';':
-                if is_typedef:
-                    words_used.discard(previous_word)
-                    look_for_words.discard(previous_word)
-                    is_typedef = False
-            elif word == 'typedef':
-                is_typedef = True
-                paren = 0
-            elif word == '(':
-                paren += 1
-            elif word == ')':
-                paren -= 1
-            elif word == ',':
-                if is_typedef and paren == 0:
-                    words_used.discard(previous_word)
-                    look_for_words.discard(previous_word)
-            else:   # word in COMMON_TYPES
-                words_used.add(word)
-        previous_word = word
-    return words_used
-
-
-class Parser(object):
-
-    def __init__(self):
-        self._declarations = {}
-        self._included_declarations = set()
-        self._anonymous_counter = 0
-        self._structnode2type = weakref.WeakKeyDictionary()
-        self._options = {}
-        self._int_constants = {}
-        self._recomplete = []
-        self._uses_new_feature = None
-
-    def _parse(self, csource):
-        csource, macros = _preprocess(csource)
-        # XXX: for more efficiency we would need to poke into the
-        # internals of CParser...  the following registers the
-        # typedefs, because their presence or absence influences the
-        # parsing itself (but what they are typedef'ed to plays no role)
-        ctn = _common_type_names(csource)
-        typenames = []
-        for name in sorted(self._declarations):
-            if name.startswith('typedef '):
-                name = name[8:]
-                typenames.append(name)
-                ctn.discard(name)
-        typenames += sorted(ctn)
-        #
-        csourcelines = []
-        csourcelines.append('# 1 "<cdef automatic initialization code>"')
-        for typename in typenames:
-            csourcelines.append('typedef int %s;' % typename)
-        csourcelines.append('typedef int __dotdotdotint__, __dotdotdotfloat__,'
-                            ' __dotdotdot__;')
-        # this forces pycparser to consider the following in the file
-        # called <cdef source string> from line 1
-        csourcelines.append('# 1 "%s"' % (CDEF_SOURCE_STRING,))
-        csourcelines.append(csource)
-        fullcsource = '\n'.join(csourcelines)
-        if lock is not None:
-            lock.acquire()     # pycparser is not thread-safe...
-        try:
-            ast = _get_parser().parse(fullcsource)
-        except pycparser.c_parser.ParseError as e:
-            self.convert_pycparser_error(e, csource)
-        finally:
-            if lock is not None:
-                lock.release()
-        # csource will be used to find buggy source text
-        return ast, macros, csource
-
-    def _convert_pycparser_error(self, e, csource):
-        # xxx look for "<cdef source string>:NUM:" at the start of str(e)
-        # and interpret that as a line number.  This will not work if
-        # the user gives explicit ``# NUM "FILE"`` directives.
-        line = None
-        msg = str(e)
-        match = re.match(r"%s:(\d+):" % (CDEF_SOURCE_STRING,), msg)
-        if match:
-            linenum = int(match.group(1), 10)
-            csourcelines = csource.splitlines()
-            if 1 <= linenum <= len(csourcelines):
-                line = csourcelines[linenum-1]
-        return line
-
-    def convert_pycparser_error(self, e, csource):
-        line = self._convert_pycparser_error(e, csource)
-
-        msg = str(e)
-        if line:
-            msg = 'cannot parse "%s"\n%s' % (line.strip(), msg)
-        else:
-            msg = 'parse error\n%s' % (msg,)
-        raise CDefError(msg)
-
-    def parse(self, csource, override=False, packed=False, dllexport=False):
-        prev_options = self._options
-        try:
-            self._options = {'override': override,
-                             'packed': packed,
-                             'dllexport': dllexport}
-            self._internal_parse(csource)
-        finally:
-            self._options = prev_options
-
-    def _internal_parse(self, csource):
-        ast, macros, csource = self._parse(csource)
-        # add the macros
-        self._process_macros(macros)
-        # find the first "__dotdotdot__" and use that as a separator
-        # between the repeated typedefs and the real csource
-        iterator = iter(ast.ext)
-        for decl in iterator:
-            if decl.name == '__dotdotdot__':
-                break
-        else:
-            assert 0
-        current_decl = None
-        #
-        try:
-            self._inside_extern_python = '__cffi_extern_python_stop'
-            for decl in iterator:
-                current_decl = decl
-                if isinstance(decl, pycparser.c_ast.Decl):
-                    self._parse_decl(decl)
-                elif isinstance(decl, pycparser.c_ast.Typedef):
-                    if not decl.name:
-                        raise CDefError("typedef does not declare any name",
-                                        decl)
-                    quals = 0
-                    if (isinstance(decl.type.type, pycparser.c_ast.IdentifierType) and
-                            decl.type.type.names[-1].startswith('__dotdotdot')):
-                        realtype = self._get_unknown_type(decl)
-                    elif (isinstance(decl.type, pycparser.c_ast.PtrDecl) and
-                          isinstance(decl.type.type, pycparser.c_ast.TypeDecl) and
-                          isinstance(decl.type.type.type,
-                                     pycparser.c_ast.IdentifierType) and
-                          decl.type.type.type.names[-1].startswith('__dotdotdot')):
-                        realtype = self._get_unknown_ptr_type(decl)
-                    else:
-                        realtype, quals = self._get_type_and_quals(
-                            decl.type, name=decl.name, partial_length_ok=True)
-                    self._declare('typedef ' + decl.name, realtype, quals=quals)
-                elif decl.__class__.__name__ == 'Pragma':
-                    pass    # skip pragma, only in pycparser 2.15
-                else:
-                    raise CDefError("unexpected <%s>: this construct is valid "
-                                    "C but not valid in cdef()" %
-                                    decl.__class__.__name__, decl)
-        except CDefError as e:
-            if len(e.args) == 1:
-                e.args = e.args + (current_decl,)
-            raise
-        except FFIError as e:
-            msg = self._convert_pycparser_error(e, csource)
-            if msg:
-                e.args = (e.args[0] + "\n    *** Err: %s" % msg,)
-            raise
-
-    def _add_constants(self, key, val):
-        if key in self._int_constants:
-            if self._int_constants[key] == val:
-                return     # ignore identical double declarations
-            raise FFIError(
-                "multiple declarations of constant: %s" % (key,))
-        self._int_constants[key] = val
-
-    def _add_integer_constant(self, name, int_str):
-        int_str = int_str.lower().rstrip("ul")
-        neg = int_str.startswith('-')
-        if neg:
-            int_str = int_str[1:]
-        # "010" is not valid oct in py3
-        if (int_str.startswith("0") and int_str != '0'
-                and not int_str.startswith("0x")):
-            int_str = "0o" + int_str[1:]
-        pyvalue = int(int_str, 0)
-        if neg:
-            pyvalue = -pyvalue
-        self._add_constants(name, pyvalue)
-        self._declare('macro ' + name, pyvalue)
-
-    def _process_macros(self, macros):
-        for key, value in macros.items():
-            value = value.strip()
-            if _r_int_literal.match(value):
-                self._add_integer_constant(key, value)
-            elif value == '...':
-                self._declare('macro ' + key, value)
-            else:
-                raise CDefError(
-                    'only supports one of the following syntax:\n'
-                    '  #define %s ...     (literally dot-dot-dot)\n'
-                    '  #define %s NUMBER  (with NUMBER an integer'
-                                    ' constant, decimal/hex/octal)\n'
-                    'got:\n'
-                    '  #define %s %s'
-                    % (key, key, key, value))
-
-    def _declare_function(self, tp, quals, decl):
-        tp = self._get_type_pointer(tp, quals)
-        if self._options.get('dllexport'):
-            tag = 'dllexport_python '
-        elif self._inside_extern_python == '__cffi_extern_python_start':
-            tag = 'extern_python '
-        elif self._inside_extern_python == '__cffi_extern_python_plus_c_start':
-            tag = 'extern_python_plus_c '
-        else:
-            tag = 'function '
-        self._declare(tag + decl.name, tp)
-
-    def _parse_decl(self, decl):
-        node = decl.type
-        if isinstance(node, pycparser.c_ast.FuncDecl):
-            tp, quals = self._get_type_and_quals(node, name=decl.name)
-            assert isinstance(tp, model.RawFunctionType)
-            self._declare_function(tp, quals, decl)
-        else:
-            if isinstance(node, pycparser.c_ast.Struct):
-                self._get_struct_union_enum_type('struct', node)
-            elif isinstance(node, pycparser.c_ast.Union):
-                self._get_struct_union_enum_type('union', node)
-            elif isinstance(node, pycparser.c_ast.Enum):
-                self._get_struct_union_enum_type('enum', node)
-            elif not decl.name:
-                raise CDefError("construct does not declare any variable",
-                                decl)
-            #
-            if decl.name:
-                tp, quals = self._get_type_and_quals(node,
-                                                     partial_length_ok=True)
-                if tp.is_raw_function:
-                    self._declare_function(tp, quals, decl)
-                elif (tp.is_integer_type() and
-                        hasattr(decl, 'init') and
-                        hasattr(decl.init, 'value') and
-                        _r_int_literal.match(decl.init.value)):
-                    self._add_integer_constant(decl.name, decl.init.value)
-                elif (tp.is_integer_type() and
-                        isinstance(decl.init, pycparser.c_ast.UnaryOp) and
-                        decl.init.op == '-' and
-                        hasattr(decl.init.expr, 'value') and
-                        _r_int_literal.match(decl.init.expr.value)):
-                    self._add_integer_constant(decl.name,
-                                               '-' + decl.init.expr.value)
-                elif (tp is model.void_type and
-                      decl.name.startswith('__cffi_extern_python_')):
-                    # hack: `extern "Python"` in the C source is replaced
-                    # with "void __cffi_extern_python_start;" and
-                    # "void __cffi_extern_python_stop;"
-                    self._inside_extern_python = decl.name
-                else:
-                    if self._inside_extern_python !='__cffi_extern_python_stop':
-                        raise CDefError(
-                            "cannot declare constants or "
-                            "variables with 'extern \"Python\"'")
-                    if (quals & model.Q_CONST) and not tp.is_array_type:
-                        self._declare('constant ' + decl.name, tp, quals=quals)
-                    else:
-                        self._declare('variable ' + decl.name, tp, quals=quals)
-
-    def parse_type(self, cdecl):
-        return self.parse_type_and_quals(cdecl)[0]
-
-    def parse_type_and_quals(self, cdecl):
-        ast, macros = self._parse('void __dummy(\n%s\n);' % cdecl)[:2]
-        assert not macros
-        exprnode = ast.ext[-1].type.args.params[0]
-        if isinstance(exprnode, pycparser.c_ast.ID):
-            raise CDefError("unknown identifier '%s'" % (exprnode.name,))
-        return self._get_type_and_quals(exprnode.type)
-
-    def _declare(self, name, obj, included=False, quals=0):
-        if name in self._declarations:
-            prevobj, prevquals = self._declarations[name]
-            if prevobj is obj and prevquals == quals:
-                return
-            if not self._options.get('override'):
-                raise FFIError(
-                    "multiple declarations of %s (for interactive usage, "
-                    "try cdef(xx, override=True))" % (name,))
-        assert '__dotdotdot__' not in name.split()
-        self._declarations[name] = (obj, quals)
-        if included:
-            self._included_declarations.add(obj)
-
-    def _extract_quals(self, type):
-        quals = 0
-        if isinstance(type, (pycparser.c_ast.TypeDecl,
-                             pycparser.c_ast.PtrDecl)):
-            if 'const' in type.quals:
-                quals |= model.Q_CONST
-            if 'volatile' in type.quals:
-                quals |= model.Q_VOLATILE
-            if 'restrict' in type.quals:
-                quals |= model.Q_RESTRICT
-        return quals
-
-    def _get_type_pointer(self, type, quals, declname=None):
-        if isinstance(type, model.RawFunctionType):
-            return type.as_function_pointer()
-        if (isinstance(type, model.StructOrUnionOrEnum) and
-                type.name.startswith('$') and type.name[1:].isdigit() and
-                type.forcename is None and declname is not None):
-            return model.NamedPointerType(type, declname, quals)
-        return model.PointerType(type, quals)
-
-    def _get_type_and_quals(self, typenode, name=None, partial_length_ok=False):
-        # first, dereference typedefs, if we have it already parsed, we're good
-        if (isinstance(typenode, pycparser.c_ast.TypeDecl) and
-            isinstance(typenode.type, pycparser.c_ast.IdentifierType) and
-            len(typenode.type.names) == 1 and
-            ('typedef ' + typenode.type.names[0]) in self._declarations):
-            tp, quals = self._declarations['typedef ' + typenode.type.names[0]]
-            quals |= self._extract_quals(typenode)
-            return tp, quals
-        #
-        if isinstance(typenode, pycparser.c_ast.ArrayDecl):
-            # array type
-            if typenode.dim is None:
-                length = None
-            else:
-                length = self._parse_constant(
-                    typenode.dim, partial_length_ok=partial_length_ok)
-            tp, quals = self._get_type_and_quals(typenode.type,
-                                partial_length_ok=partial_length_ok)
-            return model.ArrayType(tp, length), quals
-        #
-        if isinstance(typenode, pycparser.c_ast.PtrDecl):
-            # pointer type
-            itemtype, itemquals = self._get_type_and_quals(typenode.type)
-            tp = self._get_type_pointer(itemtype, itemquals, declname=name)
-            quals = self._extract_quals(typenode)
-            return tp, quals
-        #
-        if isinstance(typenode, pycparser.c_ast.TypeDecl):
-            quals = self._extract_quals(typenode)
-            type = typenode.type
-            if isinstance(type, pycparser.c_ast.IdentifierType):
-                # assume a primitive type.  get it from .names, but reduce
-                # synonyms to a single chosen combination
-                names = list(type.names)
-                if names != ['signed', 'char']:    # keep this unmodified
-                    prefixes = {}
-                    while names:
-                        name = names[0]
-                        if name in ('short', 'long', 'signed', 'unsigned'):
-                            prefixes[name] = prefixes.get(name, 0) + 1
-                            del names[0]
-                        else:
-                            break
-                    # ignore the 'signed' prefix below, and reorder the others
-                    newnames = []
-                    for prefix in ('unsigned', 'short', 'long'):
-                        for i in range(prefixes.get(prefix, 0)):
-                            newnames.append(prefix)
-                    if not names:
-                        names = ['int']    # implicitly
-                    if names == ['int']:   # but kill it if 'short' or 'long'
-                        if 'short' in prefixes or 'long' in prefixes:
-                            names = []
-                    names = newnames + names
-                ident = ' '.join(names)
-                if ident == 'void':
-                    return model.void_type, quals
-                if ident == '__dotdotdot__':
-                    raise FFIError(':%d: bad usage of "..."' %
-                            typenode.coord.line)
-                tp0, quals0 = resolve_common_type(self, ident)
-                return tp0, (quals | quals0)
-            #
-            if isinstance(type, pycparser.c_ast.Struct):
-                # 'struct foobar'
-                tp = self._get_struct_union_enum_type('struct', type, name)
-                return tp, quals
-            #
-            if isinstance(type, pycparser.c_ast.Union):
-                # 'union foobar'
-                tp = self._get_struct_union_enum_type('union', type, name)
-                return tp, quals
-            #
-            if isinstance(type, pycparser.c_ast.Enum):
-                # 'enum foobar'
-                tp = self._get_struct_union_enum_type('enum', type, name)
-                return tp, quals
-        #
-        if isinstance(typenode, pycparser.c_ast.FuncDecl):
-            # a function type
-            return self._parse_function_type(typenode, name), 0
-        #
-        # nested anonymous structs or unions end up here
-        if isinstance(typenode, pycparser.c_ast.Struct):
-            return self._get_struct_union_enum_type('struct', typenode, name,
-                                                    nested=True), 0
-        if isinstance(typenode, pycparser.c_ast.Union):
-            return self._get_struct_union_enum_type('union', typenode, name,
-                                                    nested=True), 0
-        #
-        raise FFIError(":%d: bad or unsupported type declaration" %
-                typenode.coord.line)
-
-    def _parse_function_type(self, typenode, funcname=None):
-        params = list(getattr(typenode.args, 'params', []))
-        for i, arg in enumerate(params):
-            if not hasattr(arg, 'type'):
-                raise CDefError("%s arg %d: unknown type '%s'"
-                    " (if you meant to use the old C syntax of giving"
-                    " untyped arguments, it is not supported)"
-                    % (funcname or 'in expression', i + 1,
-                       getattr(arg, 'name', '?')))
-        ellipsis = (
-            len(params) > 0 and
-            isinstance(params[-1].type, pycparser.c_ast.TypeDecl) and
-            isinstance(params[-1].type.type,
-                       pycparser.c_ast.IdentifierType) and
-            params[-1].type.type.names == ['__dotdotdot__'])
-        if ellipsis:
-            params.pop()
-            if not params:
-                raise CDefError(
-                    "%s: a function with only '(...)' as argument"
-                    " is not correct C" % (funcname or 'in expression'))
-        args = [self._as_func_arg(*self._get_type_and_quals(argdeclnode.type))
-                for argdeclnode in params]
-        if not ellipsis and args == [model.void_type]:
-            args = []
-        result, quals = self._get_type_and_quals(typenode.type)
-        # the 'quals' on the result type are ignored.  HACK: we absure them
-        # to detect __stdcall functions: we textually replace "__stdcall"
-        # with "volatile volatile const" above.
-        abi = None
-        if hasattr(typenode.type, 'quals'): # else, probable syntax error anyway
-            if typenode.type.quals[-3:] == ['volatile', 'volatile', 'const']:
-                abi = '__stdcall'
-        return model.RawFunctionType(tuple(args), result, ellipsis, abi)
-
-    def _as_func_arg(self, type, quals):
-        if isinstance(type, model.ArrayType):
-            return model.PointerType(type.item, quals)
-        elif isinstance(type, model.RawFunctionType):
-            return type.as_function_pointer()
-        else:
-            return type
-
-    def _get_struct_union_enum_type(self, kind, type, name=None, nested=False):
-        # First, a level of caching on the exact 'type' node of the AST.
-        # This is obscure, but needed because pycparser "unrolls" declarations
-        # such as "typedef struct { } foo_t, *foo_p" and we end up with
-        # an AST that is not a tree, but a DAG, with the "type" node of the
-        # two branches foo_t and foo_p of the trees being the same node.
-        # It's a bit silly but detecting "DAG-ness" in the AST tree seems
-        # to be the only way to distinguish this case from two independent
-        # structs.  See test_struct_with_two_usages.
-        try:
-            return self._structnode2type[type]
-        except KeyError:
-            pass
-        #
-        # Note that this must handle parsing "struct foo" any number of
-        # times and always return the same StructType object.  Additionally,
-        # one of these times (not necessarily the first), the fields of
-        # the struct can be specified with "struct foo { ...fields... }".
-        # If no name is given, then we have to create a new anonymous struct
-        # with no caching; in this case, the fields are either specified
-        # right now or never.
-        #
-        force_name = name
-        name = type.name
-        #
-        # get the type or create it if needed
-        if name is None:
-            # 'force_name' is used to guess a more readable name for
-            # anonymous structs, for the common case "typedef struct { } foo".
-            if force_name is not None:
-                explicit_name = '$%s' % force_name
-            else:
-                self._anonymous_counter += 1
-                explicit_name = '$%d' % self._anonymous_counter
-            tp = None
-        else:
-            explicit_name = name
-            key = '%s %s' % (kind, name)
-            tp, _ = self._declarations.get(key, (None, None))
-        #
-        if tp is None:
-            if kind == 'struct':
-                tp = model.StructType(explicit_name, None, None, None)
-            elif kind == 'union':
-                tp = model.UnionType(explicit_name, None, None, None)
-            elif kind == 'enum':
-                if explicit_name == '__dotdotdot__':
-                    raise CDefError("Enums cannot be declared with ...")
-                tp = self._build_enum_type(explicit_name, type.values)
-            else:
-                raise AssertionError("kind = %r" % (kind,))
-            if name is not None:
-                self._declare(key, tp)
-        else:
-            if kind == 'enum' and type.values is not None:
-                raise NotImplementedError(
-                    "enum %s: the '{}' declaration should appear on the first "
-                    "time the enum is mentioned, not later" % explicit_name)
-        if not tp.forcename:
-            tp.force_the_name(force_name)
-        if tp.forcename and '$' in tp.name:
-            self._declare('anonymous %s' % tp.forcename, tp)
-        #
-        self._structnode2type[type] = tp
-        #
-        # enums: done here
-        if kind == 'enum':
-            return tp
-        #
-        # is there a 'type.decls'?  If yes, then this is the place in the
-        # C sources that declare the fields.  If no, then just return the
-        # existing type, possibly still incomplete.
-        if type.decls is None:
-            return tp
-        #
-        if tp.fldnames is not None:
-            raise CDefError("duplicate declaration of struct %s" % name)
-        fldnames = []
-        fldtypes = []
-        fldbitsize = []
-        fldquals = []
-        for decl in type.decls:
-            if (isinstance(decl.type, pycparser.c_ast.IdentifierType) and
-                    ''.join(decl.type.names) == '__dotdotdot__'):
-                # XXX pycparser is inconsistent: 'names' should be a list
-                # of strings, but is sometimes just one string.  Use
-                # str.join() as a way to cope with both.
-                self._make_partial(tp, nested)
-                continue
-            if decl.bitsize is None:
-                bitsize = -1
-            else:
-                bitsize = self._parse_constant(decl.bitsize)
-            self._partial_length = False
-            type, fqual = self._get_type_and_quals(decl.type,
-                                                   partial_length_ok=True)
-            if self._partial_length:
-                self._make_partial(tp, nested)
-            if isinstance(type, model.StructType) and type.partial:
-                self._make_partial(tp, nested)
-            fldnames.append(decl.name or '')
-            fldtypes.append(type)
-            fldbitsize.append(bitsize)
-            fldquals.append(fqual)
-        tp.fldnames = tuple(fldnames)
-        tp.fldtypes = tuple(fldtypes)
-        tp.fldbitsize = tuple(fldbitsize)
-        tp.fldquals = tuple(fldquals)
-        if fldbitsize != [-1] * len(fldbitsize):
-            if isinstance(tp, model.StructType) and tp.partial:
-                raise NotImplementedError("%s: using both bitfields and '...;'"
-                                          % (tp,))
-        tp.packed = self._options.get('packed')
-        if tp.completed:    # must be re-completed: it is not opaque any more
-            tp.completed = 0
-            self._recomplete.append(tp)
-        return tp
-
-    def _make_partial(self, tp, nested):
-        if not isinstance(tp, model.StructOrUnion):
-            raise CDefError("%s cannot be partial" % (tp,))
-        if not tp.has_c_name() and not nested:
-            raise NotImplementedError("%s is partial but has no C name" %(tp,))
-        tp.partial = True
-
-    def _parse_constant(self, exprnode, partial_length_ok=False):
-        # for now, limited to expressions that are an immediate number
-        # or positive/negative number
-        if isinstance(exprnode, pycparser.c_ast.Constant):
-            s = exprnode.value
-            if s.startswith('0'):
-                if s.startswith('0x') or s.startswith('0X'):
-                    return int(s, 16)
-                return int(s, 8)
-            elif '1' <= s[0] <= '9':
-                return int(s, 10)
-            elif s[0] == "'" and s[-1] == "'" and (
-                    len(s) == 3 or (len(s) == 4 and s[1] == "\\")):
-                return ord(s[-2])
-            else:
-                raise CDefError("invalid constant %r" % (s,))
-        #
-        if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and
-                exprnode.op == '+'):
-            return self._parse_constant(exprnode.expr)
-        #
-        if (isinstance(exprnode, pycparser.c_ast.UnaryOp) and
-                exprnode.op == '-'):
-            return -self._parse_constant(exprnode.expr)
-        # load previously defined int constant
-        if (isinstance(exprnode, pycparser.c_ast.ID) and
-                exprnode.name in self._int_constants):
-            return self._int_constants[exprnode.name]
-        #
-        if (isinstance(exprnode, pycparser.c_ast.ID) and
-                    exprnode.name == '__dotdotdotarray__'):
-            if partial_length_ok:
-                self._partial_length = True
-                return '...'
-            raise FFIError(":%d: unsupported '[...]' here, cannot derive "
-                           "the actual array length in this context"
-                           % exprnode.coord.line)
-        #
-        if (isinstance(exprnode, pycparser.c_ast.BinaryOp) and
-                exprnode.op == '+'):
-            return (self._parse_constant(exprnode.left) +
-                    self._parse_constant(exprnode.right))
-        #
-        if (isinstance(exprnode, pycparser.c_ast.BinaryOp) and
-                exprnode.op == '-'):
-            return (self._parse_constant(exprnode.left) -
-                    self._parse_constant(exprnode.right))
-        #
-        raise FFIError(":%d: unsupported expression: expected a "
-                       "simple numeric constant" % exprnode.coord.line)
-
-    def _build_enum_type(self, explicit_name, decls):
-        if decls is not None:
-            partial = False
-            enumerators = []
-            enumvalues = []
-            nextenumvalue = 0
-            for enum in decls.enumerators:
-                if _r_enum_dotdotdot.match(enum.name):
-                    partial = True
-                    continue
-                if enum.value is not None:
-                    nextenumvalue = self._parse_constant(enum.value)
-                enumerators.append(enum.name)
-                enumvalues.append(nextenumvalue)
-                self._add_constants(enum.name, nextenumvalue)
-                nextenumvalue += 1
-            enumerators = tuple(enumerators)
-            enumvalues = tuple(enumvalues)
-            tp = model.EnumType(explicit_name, enumerators, enumvalues)
-            tp.partial = partial
-        else:   # opaque enum
-            tp = model.EnumType(explicit_name, (), ())
-        return tp
-
-    def include(self, other):
-        for name, (tp, quals) in other._declarations.items():
-            if name.startswith('anonymous $enum_$'):
-                continue   # fix for test_anonymous_enum_include
-            kind = name.split(' ', 1)[0]
-            if kind in ('struct', 'union', 'enum', 'anonymous', 'typedef'):
-                self._declare(name, tp, included=True, quals=quals)
-        for k, v in other._int_constants.items():
-            self._add_constants(k, v)
-
-    def _get_unknown_type(self, decl):
-        typenames = decl.type.type.names
-        if typenames == ['__dotdotdot__']:
-            return model.unknown_type(decl.name)
-
-        if typenames == ['__dotdotdotint__']:
-            if self._uses_new_feature is None:
-                self._uses_new_feature = "'typedef int... %s'" % decl.name
-            return model.UnknownIntegerType(decl.name)
-
-        if typenames == ['__dotdotdotfloat__']:
-            # note: not for 'long double' so far
-            if self._uses_new_feature is None:
-                self._uses_new_feature = "'typedef float... %s'" % decl.name
-            return model.UnknownFloatType(decl.name)
-
-        raise FFIError(':%d: unsupported usage of "..." in typedef'
-                       % decl.coord.line)
-
-    def _get_unknown_ptr_type(self, decl):
-        if decl.type.type.type.names == ['__dotdotdot__']:
-            return model.unknown_ptr_type(decl.name)
-        raise FFIError(':%d: unsupported usage of "..." in typedef'
-                       % decl.coord.line)

website/web/Lib/site-packages/cffi/error.py

@@ -1,23 +0,0 @@
-
-class FFIError(Exception):
-    pass
-
-class CDefError(Exception):
-    def __str__(self):
-        try:
-            current_decl = self.args[1]
-            filename = current_decl.coord.file
-            linenum = current_decl.coord.line
-            prefix = '%s:%d: ' % (filename, linenum)
-        except (AttributeError, TypeError, IndexError):
-            prefix = ''
-        return '%s%s' % (prefix, self.args[0])
-
-class VerificationError(Exception):
-    """ An error raised when verification fails
-    """
-
-class VerificationMissing(Exception):
-    """ An error raised when incomplete structures are passed into
-    cdef, but no verification has been done
-    """

website/web/Lib/site-packages/cffi/ffiplatform.py

@@ -1,127 +0,0 @@
-import sys, os
-from .error import VerificationError
-
-
-LIST_OF_FILE_NAMES = ['sources', 'include_dirs', 'library_dirs',
-                      'extra_objects', 'depends']
-
-def get_extension(srcfilename, modname, sources=(), **kwds):
-    _hack_at_distutils()
-    from distutils.core import Extension
-    allsources = [srcfilename]
-    for src in sources:
-        allsources.append(os.path.normpath(src))
-    return Extension(name=modname, sources=allsources, **kwds)
-
-def compile(tmpdir, ext, compiler_verbose=0, debug=None):
-    """Compile a C extension module using distutils."""
-
-    _hack_at_distutils()
-    saved_environ = os.environ.copy()
-    try:
-        outputfilename = _build(tmpdir, ext, compiler_verbose, debug)
-        outputfilename = os.path.abspath(outputfilename)
-    finally:
-        # workaround for a distutils bugs where some env vars can
-        # become longer and longer every time it is used
-        for key, value in saved_environ.items():
-            if os.environ.get(key) != value:
-                os.environ[key] = value
-    return outputfilename
-
-def _build(tmpdir, ext, compiler_verbose=0, debug=None):
-    # XXX compact but horrible :-(
-    from distutils.core import Distribution
-    import distutils.errors, distutils.log
-    #
-    dist = Distribution({'ext_modules': [ext]})
-    dist.parse_config_files()
-    options = dist.get_option_dict('build_ext')
-    if debug is None:
-        debug = sys.flags.debug
-    options['debug'] = ('ffiplatform', debug)
-    options['force'] = ('ffiplatform', True)
-    options['build_lib'] = ('ffiplatform', tmpdir)
-    options['build_temp'] = ('ffiplatform', tmpdir)
-    #
-    try:
-        old_level = distutils.log.set_threshold(0) or 0
-        try:
-            distutils.log.set_verbosity(compiler_verbose)
-            dist.run_command('build_ext')
-            cmd_obj = dist.get_command_obj('build_ext')
-            [soname] = cmd_obj.get_outputs()
-        finally:
-            distutils.log.set_threshold(old_level)
-    except (distutils.errors.CompileError,
-            distutils.errors.LinkError) as e:
-        raise VerificationError('%s: %s' % (e.__class__.__name__, e))
-    #
-    return soname
-
-try:
-    from os.path import samefile
-except ImportError:
-    def samefile(f1, f2):
-        return os.path.abspath(f1) == os.path.abspath(f2)
-
-def maybe_relative_path(path):
-    if not os.path.isabs(path):
-        return path      # already relative
-    dir = path
-    names = []
-    while True:
-        prevdir = dir
-        dir, name = os.path.split(prevdir)
-        if dir == prevdir or not dir:
-            return path     # failed to make it relative
-        names.append(name)
-        try:
-            if samefile(dir, os.curdir):
-                names.reverse()
-                return os.path.join(*names)
-        except OSError:
-            pass
-
-# ____________________________________________________________
-
-try:
-    int_or_long = (int, long)
-    import cStringIO
-except NameError:
-    int_or_long = int      # Python 3
-    import io as cStringIO
-
-def _flatten(x, f):
-    if isinstance(x, str):
-        f.write('%ds%s' % (len(x), x))
-    elif isinstance(x, dict):
-        keys = sorted(x.keys())
-        f.write('%dd' % len(keys))
-        for key in keys:
-            _flatten(key, f)
-            _flatten(x[key], f)
-    elif isinstance(x, (list, tuple)):
-        f.write('%dl' % len(x))
-        for value in x:
-            _flatten(value, f)
-    elif isinstance(x, int_or_long):
-        f.write('%di' % (x,))
-    else:
-        raise TypeError(
-            "the keywords to verify() contains unsupported object %r" % (x,))
-
-def flatten(x):
-    f = cStringIO.StringIO()
-    _flatten(x, f)
-    return f.getvalue()
-
-def _hack_at_distutils():
-    # Windows-only workaround for some configurations: see
-    # https://bugs.python.org/issue23246 (Python 2.7 with 
-    # a specific MS compiler suite download)
-    if sys.platform == "win32":
-        try:
-            import setuptools    # for side-effects, patches distutils
-        except ImportError:
-            pass

website/web/Lib/site-packages/cffi/lock.py

@@ -1,30 +0,0 @@
-import sys
-
-if sys.version_info < (3,):
-    try:
-        from thread import allocate_lock
-    except ImportError:
-        from dummy_thread import allocate_lock
-else:
-    try:
-        from _thread import allocate_lock
-    except ImportError:
-        from _dummy_thread import allocate_lock
-
-
-##import sys
-##l1 = allocate_lock
-
-##class allocate_lock(object):
-##    def __init__(self):
-##        self._real = l1()
-##    def __enter__(self):
-##        for i in range(4, 0, -1):
-##            print sys._getframe(i).f_code
-##        print
-##        return self._real.__enter__()
-##    def __exit__(self, *args):
-##        return self._real.__exit__(*args)
-##    def acquire(self, f):
-##        assert f is False
-##        return self._real.acquire(f)

website/web/Lib/site-packages/cffi/model.py

@@ -1,612 +0,0 @@
-import types
-import weakref
-
-from .lock import allocate_lock
-from .error import CDefError, VerificationError, VerificationMissing
-
-# type qualifiers
-Q_CONST    = 0x01
-Q_RESTRICT = 0x02
-Q_VOLATILE = 0x04
-
-def qualify(quals, replace_with):
-    if quals & Q_CONST:
-        replace_with = ' const ' + replace_with.lstrip()
-    if quals & Q_VOLATILE:
-        replace_with = ' volatile ' + replace_with.lstrip()
-    if quals & Q_RESTRICT:
-        # It seems that __restrict is supported by gcc and msvc.
-        # If you hit some different compiler, add a #define in
-        # _cffi_include.h for it (and in its copies, documented there)
-        replace_with = ' __restrict ' + replace_with.lstrip()
-    return replace_with
-
-
-class BaseTypeByIdentity(object):
-    is_array_type = False
-    is_raw_function = False
-
-    def get_c_name(self, replace_with='', context='a C file', quals=0):
-        result = self.c_name_with_marker
-        assert result.count('&') == 1
-        # some logic duplication with ffi.getctype()... :-(
-        replace_with = replace_with.strip()
-        if replace_with:
-            if replace_with.startswith('*') and '&[' in result:
-                replace_with = '(%s)' % replace_with
-            elif not replace_with[0] in '[(':
-                replace_with = ' ' + replace_with
-        replace_with = qualify(quals, replace_with)
-        result = result.replace('&', replace_with)
-        if '$' in result:
-            raise VerificationError(
-                "cannot generate '%s' in %s: unknown type name"
-                % (self._get_c_name(), context))
-        return result
-
-    def _get_c_name(self):
-        return self.c_name_with_marker.replace('&', '')
-
-    def has_c_name(self):
-        return '$' not in self._get_c_name()
-
-    def is_integer_type(self):
-        return False
-
-    def get_cached_btype(self, ffi, finishlist, can_delay=False):
-        try:
-            BType = ffi._cached_btypes[self]
-        except KeyError:
-            BType = self.build_backend_type(ffi, finishlist)
-            BType2 = ffi._cached_btypes.setdefault(self, BType)
-            assert BType2 is BType
-        return BType
-
-    def __repr__(self):
-        return '<%s>' % (self._get_c_name(),)
-
-    def _get_items(self):
-        return [(name, getattr(self, name)) for name in self._attrs_]
-
-
-class BaseType(BaseTypeByIdentity):
-
-    def __eq__(self, other):
-        return (self.__class__ == other.__class__ and
-                self._get_items() == other._get_items())
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __hash__(self):
-        return hash((self.__class__, tuple(self._get_items())))
-
-
-class VoidType(BaseType):
-    _attrs_ = ()
-
-    def __init__(self):
-        self.c_name_with_marker = 'void&'
-
-    def build_backend_type(self, ffi, finishlist):
-        return global_cache(self, ffi, 'new_void_type')
-
-void_type = VoidType()
-
-
-class BasePrimitiveType(BaseType):
-    def is_complex_type(self):
-        return False
-
-
-class PrimitiveType(BasePrimitiveType):
-    _attrs_ = ('name',)
-
-    ALL_PRIMITIVE_TYPES = {
-        'char':               'c',
-        'short':              'i',
-        'int':                'i',
-        'long':               'i',
-        'long long':          'i',
-        'signed char':        'i',
-        'unsigned char':      'i',
-        'unsigned short':     'i',
-        'unsigned int':       'i',
-        'unsigned long':      'i',
-        'unsigned long long': 'i',
-        'float':              'f',
-        'double':             'f',
-        'long double':        'f',
-        'float _Complex':     'j',
-        'double _Complex':    'j',
-        '_Bool':              'i',
-        # the following types are not primitive in the C sense
-        'wchar_t':            'c',
-        'char16_t':           'c',
-        'char32_t':           'c',
-        'int8_t':             'i',
-        'uint8_t':            'i',
-        'int16_t':            'i',
-        'uint16_t':           'i',
-        'int32_t':            'i',
-        'uint32_t':           'i',
-        'int64_t':            'i',
-        'uint64_t':           'i',
-        'int_least8_t':       'i',
-        'uint_least8_t':      'i',
-        'int_least16_t':      'i',
-        'uint_least16_t':     'i',
-        'int_least32_t':      'i',
-        'uint_least32_t':     'i',
-        'int_least64_t':      'i',
-        'uint_least64_t':     'i',
-        'int_fast8_t':        'i',
-        'uint_fast8_t':       'i',
-        'int_fast16_t':       'i',
-        'uint_fast16_t':      'i',
-        'int_fast32_t':       'i',
-        'uint_fast32_t':      'i',
-        'int_fast64_t':       'i',
-        'uint_fast64_t':      'i',
-        'intptr_t':           'i',
-        'uintptr_t':          'i',
-        'intmax_t':           'i',
-        'uintmax_t':          'i',
-        'ptrdiff_t':          'i',
-        'size_t':             'i',
-        'ssize_t':            'i',
-        }
-
-    def __init__(self, name):
-        assert name in self.ALL_PRIMITIVE_TYPES
-        self.name = name
-        self.c_name_with_marker = name + '&'
-
-    def is_char_type(self):
-        return self.ALL_PRIMITIVE_TYPES[self.name] == 'c'
-    def is_integer_type(self):
-        return self.ALL_PRIMITIVE_TYPES[self.name] == 'i'
-    def is_float_type(self):
-        return self.ALL_PRIMITIVE_TYPES[self.name] == 'f'
-    def is_complex_type(self):
-        return self.ALL_PRIMITIVE_TYPES[self.name] == 'j'
-
-    def build_backend_type(self, ffi, finishlist):
-        return global_cache(self, ffi, 'new_primitive_type', self.name)
-
-
-class UnknownIntegerType(BasePrimitiveType):
-    _attrs_ = ('name',)
-
-    def __init__(self, name):
-        self.name = name
-        self.c_name_with_marker = name + '&'
-
-    def is_integer_type(self):
-        return True
-
-    def build_backend_type(self, ffi, finishlist):
-        raise NotImplementedError("integer type '%s' can only be used after "
-                                  "compilation" % self.name)
-
-class UnknownFloatType(BasePrimitiveType):
-    _attrs_ = ('name', )
-
-    def __init__(self, name):
-        self.name = name
-        self.c_name_with_marker = name + '&'
-
-    def build_backend_type(self, ffi, finishlist):
-        raise NotImplementedError("float type '%s' can only be used after "
-                                  "compilation" % self.name)
-
-
-class BaseFunctionType(BaseType):
-    _attrs_ = ('args', 'result', 'ellipsis', 'abi')
-
-    def __init__(self, args, result, ellipsis, abi=None):
-        self.args = args
-        self.result = result
-        self.ellipsis = ellipsis
-        self.abi = abi
-        #
-        reprargs = [arg._get_c_name() for arg in self.args]
-        if self.ellipsis:
-            reprargs.append('...')
-        reprargs = reprargs or ['void']
-        replace_with = self._base_pattern % (', '.join(reprargs),)
-        if abi is not None:
-            replace_with = replace_with[:1] + abi + ' ' + replace_with[1:]
-        self.c_name_with_marker = (
-            self.result.c_name_with_marker.replace('&', replace_with))
-
-
-class RawFunctionType(BaseFunctionType):
-    # Corresponds to a C type like 'int(int)', which is the C type of
-    # a function, but not a pointer-to-function.  The backend has no
-    # notion of such a type; it's used temporarily by parsing.
-    _base_pattern = '(&)(%s)'
-    is_raw_function = True
-
-    def build_backend_type(self, ffi, finishlist):
-        raise CDefError("cannot render the type %r: it is a function "
-                        "type, not a pointer-to-function type" % (self,))
-
-    def as_function_pointer(self):
-        return FunctionPtrType(self.args, self.result, self.ellipsis, self.abi)
-
-
-class FunctionPtrType(BaseFunctionType):
-    _base_pattern = '(*&)(%s)'
-
-    def build_backend_type(self, ffi, finishlist):
-        result = self.result.get_cached_btype(ffi, finishlist)
-        args = []
-        for tp in self.args:
-            args.append(tp.get_cached_btype(ffi, finishlist))
-        abi_args = ()
-        if self.abi == "__stdcall":
-            if not self.ellipsis:    # __stdcall ignored for variadic funcs
-                try:
-                    abi_args = (ffi._backend.FFI_STDCALL,)
-                except AttributeError:
-                    pass
-        return global_cache(self, ffi, 'new_function_type',
-                            tuple(args), result, self.ellipsis, *abi_args)
-
-    def as_raw_function(self):
-        return RawFunctionType(self.args, self.result, self.ellipsis, self.abi)
-
-
-class PointerType(BaseType):
-    _attrs_ = ('totype', 'quals')
-
-    def __init__(self, totype, quals=0):
-        self.totype = totype
-        self.quals = quals
-        extra = qualify(quals, " *&")
-        if totype.is_array_type:
-            extra = "(%s)" % (extra.lstrip(),)
-        self.c_name_with_marker = totype.c_name_with_marker.replace('&', extra)
-
-    def build_backend_type(self, ffi, finishlist):
-        BItem = self.totype.get_cached_btype(ffi, finishlist, can_delay=True)
-        return global_cache(self, ffi, 'new_pointer_type', BItem)
-
-voidp_type = PointerType(void_type)
-
-def ConstPointerType(totype):
-    return PointerType(totype, Q_CONST)
-
-const_voidp_type = ConstPointerType(void_type)
-
-
-class NamedPointerType(PointerType):
-    _attrs_ = ('totype', 'name')
-
-    def __init__(self, totype, name, quals=0):
-        PointerType.__init__(self, totype, quals)
-        self.name = name
-        self.c_name_with_marker = name + '&'
-
-
-class ArrayType(BaseType):
-    _attrs_ = ('item', 'length')
-    is_array_type = True
-
-    def __init__(self, item, length):
-        self.item = item
-        self.length = length
-        #
-        if length is None:
-            brackets = '&[]'
-        elif length == '...':
-            brackets = '&[/*...*/]'
-        else:
-            brackets = '&[%s]' % length
-        self.c_name_with_marker = (
-            self.item.c_name_with_marker.replace('&', brackets))
-
-    def resolve_length(self, newlength):
-        return ArrayType(self.item, newlength)
-
-    def build_backend_type(self, ffi, finishlist):
-        if self.length == '...':
-            raise CDefError("cannot render the type %r: unknown length" %
-                            (self,))
-        self.item.get_cached_btype(ffi, finishlist)   # force the item BType
-        BPtrItem = PointerType(self.item).get_cached_btype(ffi, finishlist)
-        return global_cache(self, ffi, 'new_array_type', BPtrItem, self.length)
-
-char_array_type = ArrayType(PrimitiveType('char'), None)
-
-
-class StructOrUnionOrEnum(BaseTypeByIdentity):
-    _attrs_ = ('name',)
-    forcename = None
-
-    def build_c_name_with_marker(self):
-        name = self.forcename or '%s %s' % (self.kind, self.name)
-        self.c_name_with_marker = name + '&'
-
-    def force_the_name(self, forcename):
-        self.forcename = forcename
-        self.build_c_name_with_marker()
-
-    def get_official_name(self):
-        assert self.c_name_with_marker.endswith('&')
-        return self.c_name_with_marker[:-1]
-
-
-class StructOrUnion(StructOrUnionOrEnum):
-    fixedlayout = None
-    completed = 0
-    partial = False
-    packed = False
-
-    def __init__(self, name, fldnames, fldtypes, fldbitsize, fldquals=None):
-        self.name = name
-        self.fldnames = fldnames
-        self.fldtypes = fldtypes
-        self.fldbitsize = fldbitsize
-        self.fldquals = fldquals
-        self.build_c_name_with_marker()
-
-    def has_anonymous_struct_fields(self):
-        if self.fldtypes is None:
-            return False
-        for name, type in zip(self.fldnames, self.fldtypes):
-            if name == '' and isinstance(type, StructOrUnion):
-                return True
-        return False
-
-    def enumfields(self):
-        fldquals = self.fldquals
-        if fldquals is None:
-            fldquals = (0,) * len(self.fldnames)
-        for name, type, bitsize, quals in zip(self.fldnames, self.fldtypes,
-                                              self.fldbitsize, fldquals):
-            if name == '' and isinstance(type, StructOrUnion):
-                # nested anonymous struct/union
-                for result in type.enumfields():
-                    yield result
-            else:
-                yield (name, type, bitsize, quals)
-
-    def force_flatten(self):
-        # force the struct or union to have a declaration that lists
-        # directly all fields returned by enumfields(), flattening
-        # nested anonymous structs/unions.
-        names = []
-        types = []
-        bitsizes = []
-        fldquals = []
-        for name, type, bitsize, quals in self.enumfields():
-            names.append(name)
-            types.append(type)
-            bitsizes.append(bitsize)
-            fldquals.append(quals)
-        self.fldnames = tuple(names)
-        self.fldtypes = tuple(types)
-        self.fldbitsize = tuple(bitsizes)
-        self.fldquals = tuple(fldquals)
-
-    def get_cached_btype(self, ffi, finishlist, can_delay=False):
-        BType = StructOrUnionOrEnum.get_cached_btype(self, ffi, finishlist,
-                                                     can_delay)
-        if not can_delay:
-            self.finish_backend_type(ffi, finishlist)
-        return BType
-
-    def finish_backend_type(self, ffi, finishlist):
-        if self.completed:
-            if self.completed != 2:
-                raise NotImplementedError("recursive structure declaration "
-                                          "for '%s'" % (self.name,))
-            return
-        BType = ffi._cached_btypes[self]
-        #
-        self.completed = 1
-        #
-        if self.fldtypes is None:
-            pass    # not completing it: it's an opaque struct
-            #
-        elif self.fixedlayout is None:
-            fldtypes = [tp.get_cached_btype(ffi, finishlist)
-                        for tp in self.fldtypes]
-            lst = list(zip(self.fldnames, fldtypes, self.fldbitsize))
-            sflags = 0
-            if self.packed:
-                sflags = 8    # SF_PACKED
-            ffi._backend.complete_struct_or_union(BType, lst, self,
-                                                  -1, -1, sflags)
-            #
-        else:
-            fldtypes = []
-            fieldofs, fieldsize, totalsize, totalalignment = self.fixedlayout
-            for i in range(len(self.fldnames)):
-                fsize = fieldsize[i]
-                ftype = self.fldtypes[i]
-                #
-                if isinstance(ftype, ArrayType) and ftype.length == '...':
-                    # fix the length to match the total size
-                    BItemType = ftype.item.get_cached_btype(ffi, finishlist)
-                    nlen, nrest = divmod(fsize, ffi.sizeof(BItemType))
-                    if nrest != 0:
-                        self._verification_error(
-                            "field '%s.%s' has a bogus size?" % (
-                            self.name, self.fldnames[i] or '{}'))
-                    ftype = ftype.resolve_length(nlen)
-                    self.fldtypes = (self.fldtypes[:i] + (ftype,) +
-                                     self.fldtypes[i+1:])
-                #
-                BFieldType = ftype.get_cached_btype(ffi, finishlist)
-                if isinstance(ftype, ArrayType) and ftype.length is None:
-                    assert fsize == 0
-                else:
-                    bitemsize = ffi.sizeof(BFieldType)
-                    if bitemsize != fsize:
-                        self._verification_error(
-                            "field '%s.%s' is declared as %d bytes, but is "
-                            "really %d bytes" % (self.name,
-                                                 self.fldnames[i] or '{}',
-                                                 bitemsize, fsize))
-                fldtypes.append(BFieldType)
-            #
-            lst = list(zip(self.fldnames, fldtypes, self.fldbitsize, fieldofs))
-            ffi._backend.complete_struct_or_union(BType, lst, self,
-                                                  totalsize, totalalignment)
-        self.completed = 2
-
-    def _verification_error(self, msg):
-        raise VerificationError(msg)
-
-    def check_not_partial(self):
-        if self.partial and self.fixedlayout is None:
-            raise VerificationMissing(self._get_c_name())
-
-    def build_backend_type(self, ffi, finishlist):
-        self.check_not_partial()
-        finishlist.append(self)
-        #
-        return global_cache(self, ffi, 'new_%s_type' % self.kind,
-                            self.get_official_name(), key=self)
-
-
-class StructType(StructOrUnion):
-    kind = 'struct'
-
-
-class UnionType(StructOrUnion):
-    kind = 'union'
-
-
-class EnumType(StructOrUnionOrEnum):
-    kind = 'enum'
-    partial = False
-    partial_resolved = False
-
-    def __init__(self, name, enumerators, enumvalues, baseinttype=None):
-        self.name = name
-        self.enumerators = enumerators
-        self.enumvalues = enumvalues
-        self.baseinttype = baseinttype
-        self.build_c_name_with_marker()
-
-    def force_the_name(self, forcename):
-        StructOrUnionOrEnum.force_the_name(self, forcename)
-        if self.forcename is None:
-            name = self.get_official_name()
-            self.forcename = '$' + name.replace(' ', '_')
-
-    def check_not_partial(self):
-        if self.partial and not self.partial_resolved:
-            raise VerificationMissing(self._get_c_name())
-
-    def build_backend_type(self, ffi, finishlist):
-        self.check_not_partial()
-        base_btype = self.build_baseinttype(ffi, finishlist)
-        return global_cache(self, ffi, 'new_enum_type',
-                            self.get_official_name(),
-                            self.enumerators, self.enumvalues,
-                            base_btype, key=self)
-
-    def build_baseinttype(self, ffi, finishlist):
-        if self.baseinttype is not None:
-            return self.baseinttype.get_cached_btype(ffi, finishlist)
-        #
-        if self.enumvalues:
-            smallest_value = min(self.enumvalues)
-            largest_value = max(self.enumvalues)
-        else:
-            import warnings
-            try:
-                # XXX!  The goal is to ensure that the warnings.warn()
-                # will not suppress the warning.  We want to get it
-                # several times if we reach this point several times.
-                __warningregistry__.clear()
-            except NameError:
-                pass
-            warnings.warn("%r has no values explicitly defined; "
-                          "guessing that it is equivalent to 'unsigned int'"
-                          % self._get_c_name())
-            smallest_value = largest_value = 0
-        if smallest_value < 0:   # needs a signed type
-            sign = 1
-            candidate1 = PrimitiveType("int")
-            candidate2 = PrimitiveType("long")
-        else:
-            sign = 0
-            candidate1 = PrimitiveType("unsigned int")
-            candidate2 = PrimitiveType("unsigned long")
-        btype1 = candidate1.get_cached_btype(ffi, finishlist)
-        btype2 = candidate2.get_cached_btype(ffi, finishlist)
-        size1 = ffi.sizeof(btype1)
-        size2 = ffi.sizeof(btype2)
-        if (smallest_value >= ((-1) << (8*size1-1)) and
-            largest_value < (1 << (8*size1-sign))):
-            return btype1
-        if (smallest_value >= ((-1) << (8*size2-1)) and
-            largest_value < (1 << (8*size2-sign))):
-            return btype2
-        raise CDefError("%s values don't all fit into either 'long' "
-                        "or 'unsigned long'" % self._get_c_name())
-
-def unknown_type(name, structname=None):
-    if structname is None:
-        structname = '$%s' % name
-    tp = StructType(structname, None, None, None)
-    tp.force_the_name(name)
-    tp.origin = "unknown_type"
-    return tp
-
-def unknown_ptr_type(name, structname=None):
-    if structname is None:
-        structname = '$$%s' % name
-    tp = StructType(structname, None, None, None)
-    return NamedPointerType(tp, name)
-
-
-global_lock = allocate_lock()
-_typecache_cffi_backend = weakref.WeakValueDictionary()
-
-def get_typecache(backend):
-    # returns _typecache_cffi_backend if backend is the _cffi_backend
-    # module, or type(backend).__typecache if backend is an instance of
-    # CTypesBackend (or some FakeBackend class during tests)
-    if isinstance(backend, types.ModuleType):
-        return _typecache_cffi_backend
-    with global_lock:
-        if not hasattr(type(backend), '__typecache'):
-            type(backend).__typecache = weakref.WeakValueDictionary()
-        return type(backend).__typecache
-
-def global_cache(srctype, ffi, funcname, *args, **kwds):
-    key = kwds.pop('key', (funcname, args))
-    assert not kwds
-    try:
-        return ffi._typecache[key]
-    except KeyError:
-        pass
-    try:
-        res = getattr(ffi._backend, funcname)(*args)
-    except NotImplementedError as e:
-        raise NotImplementedError("%s: %r: %s" % (funcname, srctype, e))
-    # note that setdefault() on WeakValueDictionary is not atomic
-    # and contains a rare bug (http://bugs.python.org/issue19542);
-    # we have to use a lock and do it ourselves
-    cache = ffi._typecache
-    with global_lock:
-        res1 = cache.get(key)
-        if res1 is None:
-            cache[key] = res
-            return res
-        else:
-            return res1
-
-def pointer_cache(ffi, BType):
-    return global_cache('?', ffi, 'new_pointer_type', BType)
-
-def attach_exception_info(e, name):
-    if e.args and type(e.args[0]) is str:
-        e.args = ('%s: %s' % (name, e.args[0]),) + e.args[1:]

website/web/Lib/site-packages/cffi/parse_c_type.h

@@ -1,181 +0,0 @@
-
-/* This part is from file 'cffi/parse_c_type.h'.  It is copied at the
-   beginning of C sources generated by CFFI's ffi.set_source(). */
-
-typedef void *_cffi_opcode_t;
-
-#define _CFFI_OP(opcode, arg)   (_cffi_opcode_t)(opcode | (((uintptr_t)(arg)) << 8))
-#define _CFFI_GETOP(cffi_opcode)    ((unsigned char)(uintptr_t)cffi_opcode)
-#define _CFFI_GETARG(cffi_opcode)   (((intptr_t)cffi_opcode) >> 8)
-
-#define _CFFI_OP_PRIMITIVE       1
-#define _CFFI_OP_POINTER         3
-#define _CFFI_OP_ARRAY           5
-#define _CFFI_OP_OPEN_ARRAY      7
-#define _CFFI_OP_STRUCT_UNION    9
-#define _CFFI_OP_ENUM           11
-#define _CFFI_OP_FUNCTION       13
-#define _CFFI_OP_FUNCTION_END   15
-#define _CFFI_OP_NOOP           17
-#define _CFFI_OP_BITFIELD       19
-#define _CFFI_OP_TYPENAME       21
-#define _CFFI_OP_CPYTHON_BLTN_V 23   // varargs
-#define _CFFI_OP_CPYTHON_BLTN_N 25   // noargs
-#define _CFFI_OP_CPYTHON_BLTN_O 27   // O  (i.e. a single arg)
-#define _CFFI_OP_CONSTANT       29
-#define _CFFI_OP_CONSTANT_INT   31
-#define _CFFI_OP_GLOBAL_VAR     33
-#define _CFFI_OP_DLOPEN_FUNC    35
-#define _CFFI_OP_DLOPEN_CONST   37
-#define _CFFI_OP_GLOBAL_VAR_F   39
-#define _CFFI_OP_EXTERN_PYTHON  41
-
-#define _CFFI_PRIM_VOID          0
-#define _CFFI_PRIM_BOOL          1
-#define _CFFI_PRIM_CHAR          2
-#define _CFFI_PRIM_SCHAR         3
-#define _CFFI_PRIM_UCHAR         4
-#define _CFFI_PRIM_SHORT         5
-#define _CFFI_PRIM_USHORT        6
-#define _CFFI_PRIM_INT           7
-#define _CFFI_PRIM_UINT          8
-#define _CFFI_PRIM_LONG          9
-#define _CFFI_PRIM_ULONG        10
-#define _CFFI_PRIM_LONGLONG     11
-#define _CFFI_PRIM_ULONGLONG    12
-#define _CFFI_PRIM_FLOAT        13
-#define _CFFI_PRIM_DOUBLE       14
-#define _CFFI_PRIM_LONGDOUBLE   15
-
-#define _CFFI_PRIM_WCHAR        16
-#define _CFFI_PRIM_INT8         17
-#define _CFFI_PRIM_UINT8        18
-#define _CFFI_PRIM_INT16        19
-#define _CFFI_PRIM_UINT16       20
-#define _CFFI_PRIM_INT32        21
-#define _CFFI_PRIM_UINT32       22
-#define _CFFI_PRIM_INT64        23
-#define _CFFI_PRIM_UINT64       24
-#define _CFFI_PRIM_INTPTR       25
-#define _CFFI_PRIM_UINTPTR      26
-#define _CFFI_PRIM_PTRDIFF      27
-#define _CFFI_PRIM_SIZE         28
-#define _CFFI_PRIM_SSIZE        29
-#define _CFFI_PRIM_INT_LEAST8   30
-#define _CFFI_PRIM_UINT_LEAST8  31
-#define _CFFI_PRIM_INT_LEAST16  32
-#define _CFFI_PRIM_UINT_LEAST16 33
-#define _CFFI_PRIM_INT_LEAST32  34
-#define _CFFI_PRIM_UINT_LEAST32 35
-#define _CFFI_PRIM_INT_LEAST64  36
-#define _CFFI_PRIM_UINT_LEAST64 37
-#define _CFFI_PRIM_INT_FAST8    38
-#define _CFFI_PRIM_UINT_FAST8   39
-#define _CFFI_PRIM_INT_FAST16   40
-#define _CFFI_PRIM_UINT_FAST16  41
-#define _CFFI_PRIM_INT_FAST32   42
-#define _CFFI_PRIM_UINT_FAST32  43
-#define _CFFI_PRIM_INT_FAST64   44
-#define _CFFI_PRIM_UINT_FAST64  45
-#define _CFFI_PRIM_INTMAX       46
-#define _CFFI_PRIM_UINTMAX      47
-#define _CFFI_PRIM_FLOATCOMPLEX 48
-#define _CFFI_PRIM_DOUBLECOMPLEX 49
-#define _CFFI_PRIM_CHAR16       50
-#define _CFFI_PRIM_CHAR32       51
-
-#define _CFFI__NUM_PRIM         52
-#define _CFFI__UNKNOWN_PRIM           (-1)
-#define _CFFI__UNKNOWN_FLOAT_PRIM     (-2)
-#define _CFFI__UNKNOWN_LONG_DOUBLE    (-3)
-
-#define _CFFI__IO_FILE_STRUCT         (-1)
-
-
-struct _cffi_global_s {
-    const char *name;
-    void *address;
-    _cffi_opcode_t type_op;
-    void *size_or_direct_fn;  // OP_GLOBAL_VAR: size, or 0 if unknown
-                              // OP_CPYTHON_BLTN_*: addr of direct function
-};
-
-struct _cffi_getconst_s {
-    unsigned long long value;
-    const struct _cffi_type_context_s *ctx;
-    int gindex;
-};
-
-struct _cffi_struct_union_s {
-    const char *name;
-    int type_index;          // -> _cffi_types, on a OP_STRUCT_UNION
-    int flags;               // _CFFI_F_* flags below
-    size_t size;
-    int alignment;
-    int first_field_index;   // -> _cffi_fields array
-    int num_fields;
-};
-#define _CFFI_F_UNION         0x01   // is a union, not a struct
-#define _CFFI_F_CHECK_FIELDS  0x02   // complain if fields are not in the
-                                     // "standard layout" or if some are missing
-#define _CFFI_F_PACKED        0x04   // for CHECK_FIELDS, assume a packed struct
-#define _CFFI_F_EXTERNAL      0x08   // in some other ffi.include()
-#define _CFFI_F_OPAQUE        0x10   // opaque
-
-struct _cffi_field_s {
-    const char *name;
-    size_t field_offset;
-    size_t field_size;
-    _cffi_opcode_t field_type_op;
-};
-
-struct _cffi_enum_s {
-    const char *name;
-    int type_index;          // -> _cffi_types, on a OP_ENUM
-    int type_prim;           // _CFFI_PRIM_xxx
-    const char *enumerators; // comma-delimited string
-};
-
-struct _cffi_typename_s {
-    const char *name;
-    int type_index;   /* if opaque, points to a possibly artificial
-                         OP_STRUCT which is itself opaque */
-};
-
-struct _cffi_type_context_s {
-    _cffi_opcode_t *types;
-    const struct _cffi_global_s *globals;
-    const struct _cffi_field_s *fields;
-    const struct _cffi_struct_union_s *struct_unions;
-    const struct _cffi_enum_s *enums;
-    const struct _cffi_typename_s *typenames;
-    int num_globals;
-    int num_struct_unions;
-    int num_enums;
-    int num_typenames;
-    const char *const *includes;
-    int num_types;
-    int flags;      /* future extension */
-};
-
-struct _cffi_parse_info_s {
-    const struct _cffi_type_context_s *ctx;
-    _cffi_opcode_t *output;
-    unsigned int output_size;
-    size_t error_location;
-    const char *error_message;
-};
-
-struct _cffi_externpy_s {
-    const char *name;
-    size_t size_of_result;
-    void *reserved1, *reserved2;
-};
-
-#ifdef _CFFI_INTERNAL
-static int parse_c_type(struct _cffi_parse_info_s *info, const char *input);
-static int search_in_globals(const struct _cffi_type_context_s *ctx,
-                             const char *search, size_t search_len);
-static int search_in_struct_unions(const struct _cffi_type_context_s *ctx,
-                                   const char *search, size_t search_len);
-#endif

website/web/Lib/site-packages/cffi/setuptools_ext.py

@@ -1,193 +0,0 @@
-import os
-import sys
-
-try:
-    basestring
-except NameError:
-    # Python 3.x
-    basestring = str
-
-def error(msg):
-    from distutils.errors import DistutilsSetupError
-    raise DistutilsSetupError(msg)
-
-
-def execfile(filename, glob):
-    # We use execfile() (here rewritten for Python 3) instead of
-    # __import__() to load the build script.  The problem with
-    # a normal import is that in some packages, the intermediate
-    # __init__.py files may already try to import the file that
-    # we are generating.
-    with open(filename) as f:
-        src = f.read()
-    src += '\n'      # Python 2.6 compatibility
-    code = compile(src, filename, 'exec')
-    exec(code, glob, glob)
-
-
-def add_cffi_module(dist, mod_spec):
-    from cffi.api import FFI
-
-    if not isinstance(mod_spec, basestring):
-        error("argument to 'cffi_modules=...' must be a str or a list of str,"
-              " not %r" % (type(mod_spec).__name__,))
-    mod_spec = str(mod_spec)
-    try:
-        build_file_name, ffi_var_name = mod_spec.split(':')
-    except ValueError:
-        error("%r must be of the form 'path/build.py:ffi_variable'" %
-              (mod_spec,))
-    if not os.path.exists(build_file_name):
-        ext = ''
-        rewritten = build_file_name.replace('.', '/') + '.py'
-        if os.path.exists(rewritten):
-            ext = ' (rewrite cffi_modules to [%r])' % (
-                rewritten + ':' + ffi_var_name,)
-        error("%r does not name an existing file%s" % (build_file_name, ext))
-
-    mod_vars = {'__name__': '__cffi__', '__file__': build_file_name}
-    execfile(build_file_name, mod_vars)
-
-    try:
-        ffi = mod_vars[ffi_var_name]
-    except KeyError:
-        error("%r: object %r not found in module" % (mod_spec,
-                                                     ffi_var_name))
-    if not isinstance(ffi, FFI):
-        ffi = ffi()      # maybe it's a function instead of directly an ffi
-    if not isinstance(ffi, FFI):
-        error("%r is not an FFI instance (got %r)" % (mod_spec,
-                                                      type(ffi).__name__))
-    if not hasattr(ffi, '_assigned_source'):
-        error("%r: the set_source() method was not called" % (mod_spec,))
-    module_name, source, source_extension, kwds = ffi._assigned_source
-    if ffi._windows_unicode:
-        kwds = kwds.copy()
-        ffi._apply_windows_unicode(kwds)
-
-    if source is None:
-        _add_py_module(dist, ffi, module_name)
-    else:
-        _add_c_module(dist, ffi, module_name, source, source_extension, kwds)
-
-def _set_py_limited_api(Extension, kwds):
-    """
-    Add py_limited_api to kwds if setuptools >= 26 is in use.
-    Do not alter the setting if it already exists.
-    Setuptools takes care of ignoring the flag on Python 2 and PyPy.
-
-    CPython itself should ignore the flag in a debugging version
-    (by not listing .abi3.so in the extensions it supports), but
-    it doesn't so far, creating troubles.  That's why we check
-    for "not hasattr(sys, 'gettotalrefcount')" (the 2.7 compatible equivalent
-    of 'd' not in sys.abiflags). (http://bugs.python.org/issue28401)
-
-    On Windows, it's better not to use py_limited_api until issue #355
-    can be resolved (by having virtualenv copy PYTHON3.DLL).  See also
-    the start of _cffi_include.h.
-    """
-    if ('py_limited_api' not in kwds and not hasattr(sys, 'gettotalrefcount')
-            and sys.platform != 'win32'):
-        import setuptools
-        try:
-            setuptools_major_version = int(setuptools.__version__.partition('.')[0])
-            if setuptools_major_version >= 26:
-                kwds['py_limited_api'] = True
-        except ValueError:  # certain development versions of setuptools
-            # If we don't know the version number of setuptools, we
-            # try to set 'py_limited_api' anyway.  At worst, we get a
-            # warning.
-            kwds['py_limited_api'] = True
-    return kwds
-
-def _add_c_module(dist, ffi, module_name, source, source_extension, kwds):
-    from distutils.core import Extension
-    # We are a setuptools extension. Need this build_ext for py_limited_api.
-    from setuptools.command.build_ext import build_ext
-    from distutils.dir_util import mkpath
-    from distutils import log
-    from cffi import recompiler
-
-    allsources = ['$PLACEHOLDER']
-    allsources.extend(kwds.pop('sources', []))
-    kwds = _set_py_limited_api(Extension, kwds)
-    ext = Extension(name=module_name, sources=allsources, **kwds)
-
-    def make_mod(tmpdir, pre_run=None):
-        c_file = os.path.join(tmpdir, module_name + source_extension)
-        log.info("generating cffi module %r" % c_file)
-        mkpath(tmpdir)
-        # a setuptools-only, API-only hook: called with the "ext" and "ffi"
-        # arguments just before we turn the ffi into C code.  To use it,
-        # subclass the 'distutils.command.build_ext.build_ext' class and
-        # add a method 'def pre_run(self, ext, ffi)'.
-        if pre_run is not None:
-            pre_run(ext, ffi)
-        updated = recompiler.make_c_source(ffi, module_name, source, c_file)
-        if not updated:
-            log.info("already up-to-date")
-        return c_file
-
-    if dist.ext_modules is None:
-        dist.ext_modules = []
-    dist.ext_modules.append(ext)
-
-    base_class = dist.cmdclass.get('build_ext', build_ext)
-    class build_ext_make_mod(base_class):
-        def run(self):
-            if ext.sources[0] == '$PLACEHOLDER':
-                pre_run = getattr(self, 'pre_run', None)
-                ext.sources[0] = make_mod(self.build_temp, pre_run)
-            base_class.run(self)
-    dist.cmdclass['build_ext'] = build_ext_make_mod
-    # NB. multiple runs here will create multiple 'build_ext_make_mod'
-    # classes.  Even in this case the 'build_ext' command should be
-    # run once; but just in case, the logic above does nothing if
-    # called again.
-
-
-def _add_py_module(dist, ffi, module_name):
-    from distutils.dir_util import mkpath
-    from distutils.command.build_py import build_py
-    from distutils.command.build_ext import build_ext
-    from distutils import log
-    from cffi import recompiler
-
-    def generate_mod(py_file):
-        log.info("generating cffi module %r" % py_file)
-        mkpath(os.path.dirname(py_file))
-        updated = recompiler.make_py_source(ffi, module_name, py_file)
-        if not updated:
-            log.info("already up-to-date")
-
-    base_class = dist.cmdclass.get('build_py', build_py)
-    class build_py_make_mod(base_class):
-        def run(self):
-            base_class.run(self)
-            module_path = module_name.split('.')
-            module_path[-1] += '.py'
-            generate_mod(os.path.join(self.build_lib, *module_path))
-    dist.cmdclass['build_py'] = build_py_make_mod
-
-    # the following is only for "build_ext -i"
-    base_class_2 = dist.cmdclass.get('build_ext', build_ext)
-    class build_ext_make_mod(base_class_2):
-        def run(self):
-            base_class_2.run(self)
-            if self.inplace:
-                # from get_ext_fullpath() in distutils/command/build_ext.py
-                module_path = module_name.split('.')
-                package = '.'.join(module_path[:-1])
-                build_py = self.get_finalized_command('build_py')
-                package_dir = build_py.get_package_dir(package)
-                file_name = module_path[-1] + '.py'
-                generate_mod(os.path.join(package_dir, file_name))
-    dist.cmdclass['build_ext'] = build_ext_make_mod
-
-def cffi_modules(dist, attr, value):
-    assert attr == 'cffi_modules'
-    if isinstance(value, basestring):
-        value = [value]
-
-    for cffi_module in value:
-        add_cffi_module(dist, cffi_module)

website/web/Lib/site-packages/cffi/vengine_gen.py

@@ -1,675 +0,0 @@
-#
-# DEPRECATED: implementation for ffi.verify()
-#
-import sys, os
-import types
-
-from . import model
-from .error import VerificationError
-
-
-class VGenericEngine(object):
-    _class_key = 'g'
-    _gen_python_module = False
-
-    def __init__(self, verifier):
-        self.verifier = verifier
-        self.ffi = verifier.ffi
-        self.export_symbols = []
-        self._struct_pending_verification = {}
-
-    def patch_extension_kwds(self, kwds):
-        # add 'export_symbols' to the dictionary.  Note that we add the
-        # list before filling it.  When we fill it, it will thus also show
-        # up in kwds['export_symbols'].
-        kwds.setdefault('export_symbols', self.export_symbols)
-
-    def find_module(self, module_name, path, so_suffixes):
-        for so_suffix in so_suffixes:
-            basename = module_name + so_suffix
-            if path is None:
-                path = sys.path
-            for dirname in path:
-                filename = os.path.join(dirname, basename)
-                if os.path.isfile(filename):
-                    return filename
-
-    def collect_types(self):
-        pass      # not needed in the generic engine
-
-    def _prnt(self, what=''):
-        self._f.write(what + '\n')
-
-    def write_source_to_f(self):
-        prnt = self._prnt
-        # first paste some standard set of lines that are mostly '#include'
-        prnt(cffimod_header)
-        # then paste the C source given by the user, verbatim.
-        prnt(self.verifier.preamble)
-        #
-        # call generate_gen_xxx_decl(), for every xxx found from
-        # ffi._parser._declarations.  This generates all the functions.
-        self._generate('decl')
-        #
-        # on Windows, distutils insists on putting init_cffi_xyz in
-        # 'export_symbols', so instead of fighting it, just give up and
-        # give it one
-        if sys.platform == 'win32':
-            if sys.version_info >= (3,):
-                prefix = 'PyInit_'
-            else:
-                prefix = 'init'
-            modname = self.verifier.get_module_name()
-            prnt("void %s%s(void) { }\n" % (prefix, modname))
-
-    def load_library(self, flags=0):
-        # import it with the CFFI backend
-        backend = self.ffi._backend
-        # needs to make a path that contains '/', on Posix
-        filename = os.path.join(os.curdir, self.verifier.modulefilename)
-        module = backend.load_library(filename, flags)
-        #
-        # call loading_gen_struct() to get the struct layout inferred by
-        # the C compiler
-        self._load(module, 'loading')
-
-        # build the FFILibrary class and instance, this is a module subclass
-        # because modules are expected to have usually-constant-attributes and
-        # in PyPy this means the JIT is able to treat attributes as constant,
-        # which we want.
-        class FFILibrary(types.ModuleType):
-            _cffi_generic_module = module
-            _cffi_ffi = self.ffi
-            _cffi_dir = []
-            def __dir__(self):
-                return FFILibrary._cffi_dir
-        library = FFILibrary("")
-        #
-        # finally, call the loaded_gen_xxx() functions.  This will set
-        # up the 'library' object.
-        self._load(module, 'loaded', library=library)
-        return library
-
-    def _get_declarations(self):
-        lst = [(key, tp) for (key, (tp, qual)) in
-                                self.ffi._parser._declarations.items()]
-        lst.sort()
-        return lst
-
-    def _generate(self, step_name):
-        for name, tp in self._get_declarations():
-            kind, realname = name.split(' ', 1)
-            try:
-                method = getattr(self, '_generate_gen_%s_%s' % (kind,
-                                                                step_name))
-            except AttributeError:
-                raise VerificationError(
-                    "not implemented in verify(): %r" % name)
-            try:
-                method(tp, realname)
-            except Exception as e:
-                model.attach_exception_info(e, name)
-                raise
-
-    def _load(self, module, step_name, **kwds):
-        for name, tp in self._get_declarations():
-            kind, realname = name.split(' ', 1)
-            method = getattr(self, '_%s_gen_%s' % (step_name, kind))
-            try:
-                method(tp, realname, module, **kwds)
-            except Exception as e:
-                model.attach_exception_info(e, name)
-                raise
-
-    def _generate_nothing(self, tp, name):
-        pass
-
-    def _loaded_noop(self, tp, name, module, **kwds):
-        pass
-
-    # ----------
-    # typedefs: generates no code so far
-
-    _generate_gen_typedef_decl   = _generate_nothing
-    _loading_gen_typedef         = _loaded_noop
-    _loaded_gen_typedef          = _loaded_noop
-
-    # ----------
-    # function declarations
-
-    def _generate_gen_function_decl(self, tp, name):
-        assert isinstance(tp, model.FunctionPtrType)
-        if tp.ellipsis:
-            # cannot support vararg functions better than this: check for its
-            # exact type (including the fixed arguments), and build it as a
-            # constant function pointer (no _cffi_f_%s wrapper)
-            self._generate_gen_const(False, name, tp)
-            return
-        prnt = self._prnt
-        numargs = len(tp.args)
-        argnames = []
-        for i, type in enumerate(tp.args):
-            indirection = ''
-            if isinstance(type, model.StructOrUnion):
-                indirection = '*'
-            argnames.append('%sx%d' % (indirection, i))
-        context = 'argument of %s' % name
-        arglist = [type.get_c_name(' %s' % arg, context)
-                   for type, arg in zip(tp.args, argnames)]
-        tpresult = tp.result
-        if isinstance(tpresult, model.StructOrUnion):
-            arglist.insert(0, tpresult.get_c_name(' *r', context))
-            tpresult = model.void_type
-        arglist = ', '.join(arglist) or 'void'
-        wrappername = '_cffi_f_%s' % name
-        self.export_symbols.append(wrappername)
-        if tp.abi:
-            abi = tp.abi + ' '
-        else:
-            abi = ''
-        funcdecl = ' %s%s(%s)' % (abi, wrappername, arglist)
-        context = 'result of %s' % name
-        prnt(tpresult.get_c_name(funcdecl, context))
-        prnt('{')
-        #
-        if isinstance(tp.result, model.StructOrUnion):
-            result_code = '*r = '
-        elif not isinstance(tp.result, model.VoidType):
-            result_code = 'return '
-        else:
-            result_code = ''
-        prnt('  %s%s(%s);' % (result_code, name, ', '.join(argnames)))
-        prnt('}')
-        prnt()
-
-    _loading_gen_function = _loaded_noop
-
-    def _loaded_gen_function(self, tp, name, module, library):
-        assert isinstance(tp, model.FunctionPtrType)
-        if tp.ellipsis:
-            newfunction = self._load_constant(False, tp, name, module)
-        else:
-            indirections = []
-            base_tp = tp
-            if (any(isinstance(typ, model.StructOrUnion) for typ in tp.args)
-                    or isinstance(tp.result, model.StructOrUnion)):
-                indirect_args = []
-                for i, typ in enumerate(tp.args):
-                    if isinstance(typ, model.StructOrUnion):
-                        typ = model.PointerType(typ)
-                        indirections.append((i, typ))
-                    indirect_args.append(typ)
-                indirect_result = tp.result
-                if isinstance(indirect_result, model.StructOrUnion):
-                    if indirect_result.fldtypes is None:
-                        raise TypeError("'%s' is used as result type, "
-                                        "but is opaque" % (
-                                            indirect_result._get_c_name(),))
-                    indirect_result = model.PointerType(indirect_result)
-                    indirect_args.insert(0, indirect_result)
-                    indirections.insert(0, ("result", indirect_result))
-                    indirect_result = model.void_type
-                tp = model.FunctionPtrType(tuple(indirect_args),
-                                           indirect_result, tp.ellipsis)
-            BFunc = self.ffi._get_cached_btype(tp)
-            wrappername = '_cffi_f_%s' % name
-            newfunction = module.load_function(BFunc, wrappername)
-            for i, typ in indirections:
-                newfunction = self._make_struct_wrapper(newfunction, i, typ,
-                                                        base_tp)
-        setattr(library, name, newfunction)
-        type(library)._cffi_dir.append(name)
-
-    def _make_struct_wrapper(self, oldfunc, i, tp, base_tp):
-        backend = self.ffi._backend
-        BType = self.ffi._get_cached_btype(tp)
-        if i == "result":
-            ffi = self.ffi
-            def newfunc(*args):
-                res = ffi.new(BType)
-                oldfunc(res, *args)
-                return res[0]
-        else:
-            def newfunc(*args):
-                args = args[:i] + (backend.newp(BType, args[i]),) + args[i+1:]
-                return oldfunc(*args)
-        newfunc._cffi_base_type = base_tp
-        return newfunc
-
-    # ----------
-    # named structs
-
-    def _generate_gen_struct_decl(self, tp, name):
-        assert name == tp.name
-        self._generate_struct_or_union_decl(tp, 'struct', name)
-
-    def _loading_gen_struct(self, tp, name, module):
-        self._loading_struct_or_union(tp, 'struct', name, module)
-
-    def _loaded_gen_struct(self, tp, name, module, **kwds):
-        self._loaded_struct_or_union(tp)
-
-    def _generate_gen_union_decl(self, tp, name):
-        assert name == tp.name
-        self._generate_struct_or_union_decl(tp, 'union', name)
-
-    def _loading_gen_union(self, tp, name, module):
-        self._loading_struct_or_union(tp, 'union', name, module)
-
-    def _loaded_gen_union(self, tp, name, module, **kwds):
-        self._loaded_struct_or_union(tp)
-
-    def _generate_struct_or_union_decl(self, tp, prefix, name):
-        if tp.fldnames is None:
-            return     # nothing to do with opaque structs
-        checkfuncname = '_cffi_check_%s_%s' % (prefix, name)
-        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
-        cname = ('%s %s' % (prefix, name)).strip()
-        #
-        prnt = self._prnt
-        prnt('static void %s(%s *p)' % (checkfuncname, cname))
-        prnt('{')
-        prnt('  /* only to generate compile-time warnings or errors */')
-        prnt('  (void)p;')
-        for fname, ftype, fbitsize, fqual in tp.enumfields():
-            if (isinstance(ftype, model.PrimitiveType)
-                and ftype.is_integer_type()) or fbitsize >= 0:
-                # accept all integers, but complain on float or double
-                prnt('  (void)((p->%s) << 1);' % fname)
-            else:
-                # only accept exactly the type declared.
-                try:
-                    prnt('  { %s = &p->%s; (void)tmp; }' % (
-                        ftype.get_c_name('*tmp', 'field %r'%fname, quals=fqual),
-                        fname))
-                except VerificationError as e:
-                    prnt('  /* %s */' % str(e))   # cannot verify it, ignore
-        prnt('}')
-        self.export_symbols.append(layoutfuncname)
-        prnt('intptr_t %s(intptr_t i)' % (layoutfuncname,))
-        prnt('{')
-        prnt('  struct _cffi_aligncheck { char x; %s y; };' % cname)
-        prnt('  static intptr_t nums[] = {')
-        prnt('    sizeof(%s),' % cname)
-        prnt('    offsetof(struct _cffi_aligncheck, y),')
-        for fname, ftype, fbitsize, fqual in tp.enumfields():
-            if fbitsize >= 0:
-                continue      # xxx ignore fbitsize for now
-            prnt('    offsetof(%s, %s),' % (cname, fname))
-            if isinstance(ftype, model.ArrayType) and ftype.length is None:
-                prnt('    0,  /* %s */' % ftype._get_c_name())
-            else:
-                prnt('    sizeof(((%s *)0)->%s),' % (cname, fname))
-        prnt('    -1')
-        prnt('  };')
-        prnt('  return nums[i];')
-        prnt('  /* the next line is not executed, but compiled */')
-        prnt('  %s(0);' % (checkfuncname,))
-        prnt('}')
-        prnt()
-
-    def _loading_struct_or_union(self, tp, prefix, name, module):
-        if tp.fldnames is None:
-            return     # nothing to do with opaque structs
-        layoutfuncname = '_cffi_layout_%s_%s' % (prefix, name)
-        #
-        BFunc = self.ffi._typeof_locked("intptr_t(*)(intptr_t)")[0]
-        function = module.load_function(BFunc, layoutfuncname)
-        layout = []
-        num = 0
-        while True:
-            x = function(num)
-            if x < 0: break
-            layout.append(x)
-            num += 1
-        if isinstance(tp, model.StructOrUnion) and tp.partial:
-            # use the function()'s sizes and offsets to guide the
-            # layout of the struct
-            totalsize = layout[0]
-            totalalignment = layout[1]
-            fieldofs = layout[2::2]
-            fieldsize = layout[3::2]
-            tp.force_flatten()
-            assert len(fieldofs) == len(fieldsize) == len(tp.fldnames)
-            tp.fixedlayout = fieldofs, fieldsize, totalsize, totalalignment
-        else:
-            cname = ('%s %s' % (prefix, name)).strip()
-            self._struct_pending_verification[tp] = layout, cname
-
-    def _loaded_struct_or_union(self, tp):
-        if tp.fldnames is None:
-            return     # nothing to do with opaque structs
-        self.ffi._get_cached_btype(tp)   # force 'fixedlayout' to be considered
-
-        if tp in self._struct_pending_verification:
-            # check that the layout sizes and offsets match the real ones
-            def check(realvalue, expectedvalue, msg):
-                if realvalue != expectedvalue:
-                    raise VerificationError(
-                        "%s (we have %d, but C compiler says %d)"
-                        % (msg, expectedvalue, realvalue))
-            ffi = self.ffi
-            BStruct = ffi._get_cached_btype(tp)
-            layout, cname = self._struct_pending_verification.pop(tp)
-            check(layout[0], ffi.sizeof(BStruct), "wrong total size")
-            check(layout[1], ffi.alignof(BStruct), "wrong total alignment")
-            i = 2
-            for fname, ftype, fbitsize, fqual in tp.enumfields():
-                if fbitsize >= 0:
-                    continue        # xxx ignore fbitsize for now
-                check(layout[i], ffi.offsetof(BStruct, fname),
-                      "wrong offset for field %r" % (fname,))
-                if layout[i+1] != 0:
-                    BField = ffi._get_cached_btype(ftype)
-                    check(layout[i+1], ffi.sizeof(BField),
-                          "wrong size for field %r" % (fname,))
-                i += 2
-            assert i == len(layout)
-
-    # ----------
-    # 'anonymous' declarations.  These are produced for anonymous structs
-    # or unions; the 'name' is obtained by a typedef.
-
-    def _generate_gen_anonymous_decl(self, tp, name):
-        if isinstance(tp, model.EnumType):
-            self._generate_gen_enum_decl(tp, name, '')
-        else:
-            self._generate_struct_or_union_decl(tp, '', name)
-
-    def _loading_gen_anonymous(self, tp, name, module):
-        if isinstance(tp, model.EnumType):
-            self._loading_gen_enum(tp, name, module, '')
-        else:
-            self._loading_struct_or_union(tp, '', name, module)
-
-    def _loaded_gen_anonymous(self, tp, name, module, **kwds):
-        if isinstance(tp, model.EnumType):
-            self._loaded_gen_enum(tp, name, module, **kwds)
-        else:
-            self._loaded_struct_or_union(tp)
-
-    # ----------
-    # constants, likely declared with '#define'
-
-    def _generate_gen_const(self, is_int, name, tp=None, category='const',
-                            check_value=None):
-        prnt = self._prnt
-        funcname = '_cffi_%s_%s' % (category, name)
-        self.export_symbols.append(funcname)
-        if check_value is not None:
-            assert is_int
-            assert category == 'const'
-            prnt('int %s(char *out_error)' % funcname)
-            prnt('{')
-            self._check_int_constant_value(name, check_value)
-            prnt('  return 0;')
-            prnt('}')
-        elif is_int:
-            assert category == 'const'
-            prnt('int %s(long long *out_value)' % funcname)
-            prnt('{')
-            prnt('  *out_value = (long long)(%s);' % (name,))
-            prnt('  return (%s) <= 0;' % (name,))
-            prnt('}')
-        else:
-            assert tp is not None
-            assert check_value is None
-            if category == 'var':
-                ampersand = '&'
-            else:
-                ampersand = ''
-            extra = ''
-            if category == 'const' and isinstance(tp, model.StructOrUnion):
-                extra = 'const *'
-                ampersand = '&'
-            prnt(tp.get_c_name(' %s%s(void)' % (extra, funcname), name))
-            prnt('{')
-            prnt('  return (%s%s);' % (ampersand, name))
-            prnt('}')
-        prnt()
-
-    def _generate_gen_constant_decl(self, tp, name):
-        is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type()
-        self._generate_gen_const(is_int, name, tp)
-
-    _loading_gen_constant = _loaded_noop
-
-    def _load_constant(self, is_int, tp, name, module, check_value=None):
-        funcname = '_cffi_const_%s' % name
-        if check_value is not None:
-            assert is_int
-            self._load_known_int_constant(module, funcname)
-            value = check_value
-        elif is_int:
-            BType = self.ffi._typeof_locked("long long*")[0]
-            BFunc = self.ffi._typeof_locked("int(*)(long long*)")[0]
-            function = module.load_function(BFunc, funcname)
-            p = self.ffi.new(BType)
-            negative = function(p)
-            value = int(p[0])
-            if value < 0 and not negative:
-                BLongLong = self.ffi._typeof_locked("long long")[0]
-                value += (1 << (8*self.ffi.sizeof(BLongLong)))
-        else:
-            assert check_value is None
-            fntypeextra = '(*)(void)'
-            if isinstance(tp, model.StructOrUnion):
-                fntypeextra = '*' + fntypeextra
-            BFunc = self.ffi._typeof_locked(tp.get_c_name(fntypeextra, name))[0]
-            function = module.load_function(BFunc, funcname)
-            value = function()
-            if isinstance(tp, model.StructOrUnion):
-                value = value[0]
-        return value
-
-    def _loaded_gen_constant(self, tp, name, module, library):
-        is_int = isinstance(tp, model.PrimitiveType) and tp.is_integer_type()
-        value = self._load_constant(is_int, tp, name, module)
-        setattr(library, name, value)
-        type(library)._cffi_dir.append(name)
-
-    # ----------
-    # enums
-
-    def _check_int_constant_value(self, name, value):
-        prnt = self._prnt
-        if value <= 0:
-            prnt('  if ((%s) > 0 || (long)(%s) != %dL) {' % (
-                name, name, value))
-        else:
-            prnt('  if ((%s) <= 0 || (unsigned long)(%s) != %dUL) {' % (
-                name, name, value))
-        prnt('    char buf[64];')
-        prnt('    if ((%s) <= 0)' % name)
-        prnt('        sprintf(buf, "%%ld", (long)(%s));' % name)
-        prnt('    else')
-        prnt('        sprintf(buf, "%%lu", (unsigned long)(%s));' %
-             name)
-        prnt('    sprintf(out_error, "%s has the real value %s, not %s",')
-        prnt('            "%s", buf, "%d");' % (name[:100], value))
-        prnt('    return -1;')
-        prnt('  }')
-
-    def _load_known_int_constant(self, module, funcname):
-        BType = self.ffi._typeof_locked("char[]")[0]
-        BFunc = self.ffi._typeof_locked("int(*)(char*)")[0]
-        function = module.load_function(BFunc, funcname)
-        p = self.ffi.new(BType, 256)
-        if function(p) < 0:
-            error = self.ffi.string(p)
-            if sys.version_info >= (3,):
-                error = str(error, 'utf-8')
-            raise VerificationError(error)
-
-    def _enum_funcname(self, prefix, name):
-        # "$enum_$1" => "___D_enum____D_1"
-        name = name.replace('$', '___D_')
-        return '_cffi_e_%s_%s' % (prefix, name)
-
-    def _generate_gen_enum_decl(self, tp, name, prefix='enum'):
-        if tp.partial:
-            for enumerator in tp.enumerators:
-                self._generate_gen_const(True, enumerator)
-            return
-        #
-        funcname = self._enum_funcname(prefix, name)
-        self.export_symbols.append(funcname)
-        prnt = self._prnt
-        prnt('int %s(char *out_error)' % funcname)
-        prnt('{')
-        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
-            self._check_int_constant_value(enumerator, enumvalue)
-        prnt('  return 0;')
-        prnt('}')
-        prnt()
-
-    def _loading_gen_enum(self, tp, name, module, prefix='enum'):
-        if tp.partial:
-            enumvalues = [self._load_constant(True, tp, enumerator, module)
-                          for enumerator in tp.enumerators]
-            tp.enumvalues = tuple(enumvalues)
-            tp.partial_resolved = True
-        else:
-            funcname = self._enum_funcname(prefix, name)
-            self._load_known_int_constant(module, funcname)
-
-    def _loaded_gen_enum(self, tp, name, module, library):
-        for enumerator, enumvalue in zip(tp.enumerators, tp.enumvalues):
-            setattr(library, enumerator, enumvalue)
-            type(library)._cffi_dir.append(enumerator)
-
-    # ----------
-    # macros: for now only for integers
-
-    def _generate_gen_macro_decl(self, tp, name):
-        if tp == '...':
-            check_value = None
-        else:
-            check_value = tp     # an integer
-        self._generate_gen_const(True, name, check_value=check_value)
-
-    _loading_gen_macro = _loaded_noop
-
-    def _loaded_gen_macro(self, tp, name, module, library):
-        if tp == '...':
-            check_value = None
-        else:
-            check_value = tp     # an integer
-        value = self._load_constant(True, tp, name, module,
-                                    check_value=check_value)
-        setattr(library, name, value)
-        type(library)._cffi_dir.append(name)
-
-    # ----------
-    # global variables
-
-    def _generate_gen_variable_decl(self, tp, name):
-        if isinstance(tp, model.ArrayType):
-            if tp.length == '...':
-                prnt = self._prnt
-                funcname = '_cffi_sizeof_%s' % (name,)
-                self.export_symbols.append(funcname)
-                prnt("size_t %s(void)" % funcname)
-                prnt("{")
-                prnt("  return sizeof(%s);" % (name,))
-                prnt("}")
-            tp_ptr = model.PointerType(tp.item)
-            self._generate_gen_const(False, name, tp_ptr)
-        else:
-            tp_ptr = model.PointerType(tp)
-            self._generate_gen_const(False, name, tp_ptr, category='var')
-
-    _loading_gen_variable = _loaded_noop
-
-    def _loaded_gen_variable(self, tp, name, module, library):
-        if isinstance(tp, model.ArrayType):   # int a[5] is "constant" in the
-                                              # sense that "a=..." is forbidden
-            if tp.length == '...':
-                funcname = '_cffi_sizeof_%s' % (name,)
-                BFunc = self.ffi._typeof_locked('size_t(*)(void)')[0]
-                function = module.load_function(BFunc, funcname)
-                size = function()
-                BItemType = self.ffi._get_cached_btype(tp.item)
-                length, rest = divmod(size, self.ffi.sizeof(BItemType))
-                if rest != 0:
-                    raise VerificationError(
-                        "bad size: %r does not seem to be an array of %s" %
-                        (name, tp.item))
-                tp = tp.resolve_length(length)
-            tp_ptr = model.PointerType(tp.item)
-            value = self._load_constant(False, tp_ptr, name, module)
-            # 'value' is a <cdata 'type *'> which we have to replace with
-            # a <cdata 'type[N]'> if the N is actually known
-            if tp.length is not None:
-                BArray = self.ffi._get_cached_btype(tp)
-                value = self.ffi.cast(BArray, value)
-            setattr(library, name, value)
-            type(library)._cffi_dir.append(name)
-            return
-        # remove ptr=<cdata 'int *'> from the library instance, and replace
-        # it by a property on the class, which reads/writes into ptr[0].
-        funcname = '_cffi_var_%s' % name
-        BFunc = self.ffi._typeof_locked(tp.get_c_name('*(*)(void)', name))[0]
-        function = module.load_function(BFunc, funcname)
-        ptr = function()
-        def getter(library):
-            return ptr[0]
-        def setter(library, value):
-            ptr[0] = value
-        setattr(type(library), name, property(getter, setter))
-        type(library)._cffi_dir.append(name)
-
-cffimod_header = r'''
-#include <stdio.h>
-#include <stddef.h>
-#include <stdarg.h>
-#include <errno.h>
-#include <sys/types.h>   /* XXX for ssize_t on some platforms */
-
-/* this block of #ifs should be kept exactly identical between
-   c/_cffi_backend.c, cffi/vengine_cpy.py, cffi/vengine_gen.py
-   and cffi/_cffi_include.h */
-#if defined(_MSC_VER)
-# include <malloc.h>   /* for alloca() */
-# if _MSC_VER < 1600   /* MSVC < 2010 */
-   typedef __int8 int8_t;
-   typedef __int16 int16_t;
-   typedef __int32 int32_t;
-   typedef __int64 int64_t;
-   typedef unsigned __int8 uint8_t;
-   typedef unsigned __int16 uint16_t;
-   typedef unsigned __int32 uint32_t;
-   typedef unsigned __int64 uint64_t;
-   typedef __int8 int_least8_t;
-   typedef __int16 int_least16_t;
-   typedef __int32 int_least32_t;
-   typedef __int64 int_least64_t;
-   typedef unsigned __int8 uint_least8_t;
-   typedef unsigned __int16 uint_least16_t;
-   typedef unsigned __int32 uint_least32_t;
-   typedef unsigned __int64 uint_least64_t;
-   typedef __int8 int_fast8_t;
-   typedef __int16 int_fast16_t;
-   typedef __int32 int_fast32_t;
-   typedef __int64 int_fast64_t;
-   typedef unsigned __int8 uint_fast8_t;
-   typedef unsigned __int16 uint_fast16_t;
-   typedef unsigned __int32 uint_fast32_t;
-   typedef unsigned __int64 uint_fast64_t;
-   typedef __int64 intmax_t;
-   typedef unsigned __int64 uintmax_t;
-# else
-#  include <stdint.h>
-# endif
-# if _MSC_VER < 1800   /* MSVC < 2013 */
-#  ifndef __cplusplus
-    typedef unsigned char _Bool;
-#  endif
-# endif
-#else
-# include <stdint.h>
-# if (defined (__SVR4) && defined (__sun)) || defined(_AIX) || defined(__hpux)
-#  include <alloca.h>
-# endif
-#endif
-'''

website/web/Lib/site-packages/cffi/verifier.py

@@ -1,306 +0,0 @@
-#
-# DEPRECATED: implementation for ffi.verify()
-#
-import sys, os, binascii, shutil, io
-from . import __version_verifier_modules__
-from . import ffiplatform
-from .error import VerificationError
-
-if sys.version_info >= (3, 3):
-    import importlib.machinery
-    def _extension_suffixes():
-        return importlib.machinery.EXTENSION_SUFFIXES[:]
-else:
-    import imp
-    def _extension_suffixes():
-        return [suffix for suffix, _, type in imp.get_suffixes()
-                if type == imp.C_EXTENSION]
-
-
-if sys.version_info >= (3,):
-    NativeIO = io.StringIO
-else:
-    class NativeIO(io.BytesIO):
-        def write(self, s):
-            if isinstance(s, unicode):
-                s = s.encode('ascii')
-            super(NativeIO, self).write(s)
-
-
-class Verifier(object):
-
-    def __init__(self, ffi, preamble, tmpdir=None, modulename=None,
-                 ext_package=None, tag='', force_generic_engine=False,
-                 source_extension='.c', flags=None, relative_to=None, **kwds):
-        if ffi._parser._uses_new_feature:
-            raise VerificationError(
-                "feature not supported with ffi.verify(), but only "
-                "with ffi.set_source(): %s" % (ffi._parser._uses_new_feature,))
-        self.ffi = ffi
-        self.preamble = preamble
-        if not modulename:
-            flattened_kwds = ffiplatform.flatten(kwds)
-        vengine_class = _locate_engine_class(ffi, force_generic_engine)
-        self._vengine = vengine_class(self)
-        self._vengine.patch_extension_kwds(kwds)
-        self.flags = flags
-        self.kwds = self.make_relative_to(kwds, relative_to)
-        #
-        if modulename:
-            if tag:
-                raise TypeError("can't specify both 'modulename' and 'tag'")
-        else:
-            key = '\x00'.join([sys.version[:3], __version_verifier_modules__,
-                               preamble, flattened_kwds] +
-                              ffi._cdefsources)
-            if sys.version_info >= (3,):
-                key = key.encode('utf-8')
-            k1 = hex(binascii.crc32(key[0::2]) & 0xffffffff)
-            k1 = k1.lstrip('0x').rstrip('L')
-            k2 = hex(binascii.crc32(key[1::2]) & 0xffffffff)
-            k2 = k2.lstrip('0').rstrip('L')
-            modulename = '_cffi_%s_%s%s%s' % (tag, self._vengine._class_key,
-                                              k1, k2)
-        suffix = _get_so_suffixes()[0]
-        self.tmpdir = tmpdir or _caller_dir_pycache()
-        self.sourcefilename = os.path.join(self.tmpdir, modulename + source_extension)
-        self.modulefilename = os.path.join(self.tmpdir, modulename + suffix)
-        self.ext_package = ext_package
-        self._has_source = False
-        self._has_module = False
-
-    def write_source(self, file=None):
-        """Write the C source code.  It is produced in 'self.sourcefilename',
-        which can be tweaked beforehand."""
-        with self.ffi._lock:
-            if self._has_source and file is None:
-                raise VerificationError(
-                    "source code already written")
-            self._write_source(file)
-
-    def compile_module(self):
-        """Write the C source code (if not done already) and compile it.
-        This produces a dynamic link library in 'self.modulefilename'."""
-        with self.ffi._lock:
-            if self._has_module:
-                raise VerificationError("module already compiled")
-            if not self._has_source:
-                self._write_source()
-            self._compile_module()
-
-    def load_library(self):
-        """Get a C module from this Verifier instance.
-        Returns an instance of a FFILibrary class that behaves like the
-        objects returned by ffi.dlopen(), but that delegates all
-        operations to the C module.  If necessary, the C code is written
-        and compiled first.
-        """
-        with self.ffi._lock:
-            if not self._has_module:
-                self._locate_module()
-                if not self._has_module:
-                    if not self._has_source:
-                        self._write_source()
-                    self._compile_module()
-            return self._load_library()
-
-    def get_module_name(self):
-        basename = os.path.basename(self.modulefilename)
-        # kill both the .so extension and the other .'s, as introduced
-        # by Python 3: 'basename.cpython-33m.so'
-        basename = basename.split('.', 1)[0]
-        # and the _d added in Python 2 debug builds --- but try to be
-        # conservative and not kill a legitimate _d
-        if basename.endswith('_d') and hasattr(sys, 'gettotalrefcount'):
-            basename = basename[:-2]
-        return basename
-
-    def get_extension(self):
-        ffiplatform._hack_at_distutils() # backward compatibility hack
-        if not self._has_source:
-            with self.ffi._lock:
-                if not self._has_source:
-                    self._write_source()
-        sourcename = ffiplatform.maybe_relative_path(self.sourcefilename)
-        modname = self.get_module_name()
-        return ffiplatform.get_extension(sourcename, modname, **self.kwds)
-
-    def generates_python_module(self):
-        return self._vengine._gen_python_module
-
-    def make_relative_to(self, kwds, relative_to):
-        if relative_to and os.path.dirname(relative_to):
-            dirname = os.path.dirname(relative_to)
-            kwds = kwds.copy()
-            for key in ffiplatform.LIST_OF_FILE_NAMES:
-                if key in kwds:
-                    lst = kwds[key]
-                    if not isinstance(lst, (list, tuple)):
-                        raise TypeError("keyword '%s' should be a list or tuple"
-                                        % (key,))
-                    lst = [os.path.join(dirname, fn) for fn in lst]
-                    kwds[key] = lst
-        return kwds
-
-    # ----------
-
-    def _locate_module(self):
-        if not os.path.isfile(self.modulefilename):
-            if self.ext_package:
-                try:
-                    pkg = __import__(self.ext_package, None, None, ['__doc__'])
-                except ImportError:
-                    return      # cannot import the package itself, give up
-                    # (e.g. it might be called differently before installation)
-                path = pkg.__path__
-            else:
-                path = None
-            filename = self._vengine.find_module(self.get_module_name(), path,
-                                                 _get_so_suffixes())
-            if filename is None:
-                return
-            self.modulefilename = filename
-        self._vengine.collect_types()
-        self._has_module = True
-
-    def _write_source_to(self, file):
-        self._vengine._f = file
-        try:
-            self._vengine.write_source_to_f()
-        finally:
-            del self._vengine._f
-
-    def _write_source(self, file=None):
-        if file is not None:
-            self._write_source_to(file)
-        else:
-            # Write our source file to an in memory file.
-            f = NativeIO()
-            self._write_source_to(f)
-            source_data = f.getvalue()
-
-            # Determine if this matches the current file
-            if os.path.exists(self.sourcefilename):
-                with open(self.sourcefilename, "r") as fp:
-                    needs_written = not (fp.read() == source_data)
-            else:
-                needs_written = True
-
-            # Actually write the file out if it doesn't match
-            if needs_written:
-                _ensure_dir(self.sourcefilename)
-                with open(self.sourcefilename, "w") as fp:
-                    fp.write(source_data)
-
-            # Set this flag
-            self._has_source = True
-
-    def _compile_module(self):
-        # compile this C source
-        tmpdir = os.path.dirname(self.sourcefilename)
-        outputfilename = ffiplatform.compile(tmpdir, self.get_extension())
-        try:
-            same = ffiplatform.samefile(outputfilename, self.modulefilename)
-        except OSError:
-            same = False
-        if not same:
-            _ensure_dir(self.modulefilename)
-            shutil.move(outputfilename, self.modulefilename)
-        self._has_module = True
-
-    def _load_library(self):
-        assert self._has_module
-        if self.flags is not None:
-            return self._vengine.load_library(self.flags)
-        else:
-            return self._vengine.load_library()
-
-# ____________________________________________________________
-
-_FORCE_GENERIC_ENGINE = False      # for tests
-
-def _locate_engine_class(ffi, force_generic_engine):
-    if _FORCE_GENERIC_ENGINE:
-        force_generic_engine = True
-    if not force_generic_engine:
-        if '__pypy__' in sys.builtin_module_names:
-            force_generic_engine = True
-        else:
-            try:
-                import _cffi_backend
-            except ImportError:
-                _cffi_backend = '?'
-            if ffi._backend is not _cffi_backend:
-                force_generic_engine = True
-    if force_generic_engine:
-        from . import vengine_gen
-        return vengine_gen.VGenericEngine
-    else:
-        from . import vengine_cpy
-        return vengine_cpy.VCPythonEngine
-
-# ____________________________________________________________
-
-_TMPDIR = None
-
-def _caller_dir_pycache():
-    if _TMPDIR:
-        return _TMPDIR
-    result = os.environ.get('CFFI_TMPDIR')
-    if result:
-        return result
-    filename = sys._getframe(2).f_code.co_filename
-    return os.path.abspath(os.path.join(os.path.dirname(filename),
-                           '__pycache__'))
-
-def set_tmpdir(dirname):
-    """Set the temporary directory to use instead of __pycache__."""
-    global _TMPDIR
-    _TMPDIR = dirname
-
-def cleanup_tmpdir(tmpdir=None, keep_so=False):
-    """Clean up the temporary directory by removing all files in it
-    called `_cffi_*.{c,so}` as well as the `build` subdirectory."""
-    tmpdir = tmpdir or _caller_dir_pycache()
-    try:
-        filelist = os.listdir(tmpdir)
-    except OSError:
-        return
-    if keep_so:
-        suffix = '.c'   # only remove .c files
-    else:
-        suffix = _get_so_suffixes()[0].lower()
-    for fn in filelist:
-        if fn.lower().startswith('_cffi_') and (
-                fn.lower().endswith(suffix) or fn.lower().endswith('.c')):
-            try:
-                os.unlink(os.path.join(tmpdir, fn))
-            except OSError:
-                pass
-    clean_dir = [os.path.join(tmpdir, 'build')]
-    for dir in clean_dir:
-        try:
-            for fn in os.listdir(dir):
-                fn = os.path.join(dir, fn)
-                if os.path.isdir(fn):
-                    clean_dir.append(fn)
-                else:
-                    os.unlink(fn)
-        except OSError:
-            pass
-
-def _get_so_suffixes():
-    suffixes = _extension_suffixes()
-    if not suffixes:
-        # bah, no C_EXTENSION available.  Occurs on pypy without cpyext
-        if sys.platform == 'win32':
-            suffixes = [".pyd"]
-        else:
-            suffixes = [".so"]
-
-    return suffixes
-
-def _ensure_dir(filename):
-    dirname = os.path.dirname(filename)
-    if dirname and not os.path.isdir(dirname):
-        os.makedirs(dirname)

website/web/Lib/site-packages/click-6.7.dist-info/DESCRIPTION.rst

@@ -1,3 +0,0 @@
-UNKNOWN
-
-

website/web/Lib/site-packages/click-6.7.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

website/web/Lib/site-packages/click-6.7.dist-info/METADATA

@@ -1,16 +0,0 @@
-Metadata-Version: 2.0
-Name: click
-Version: 6.7
-Summary: A simple wrapper around optparse for powerful command line utilities.
-Home-page: http://github.com/mitsuhiko/click
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-
-UNKNOWN
-
-

website/web/Lib/site-packages/click-6.7.dist-info/RECORD

@@ -1,41 +0,0 @@
-click/__init__.py,sha256=k8R00cFKWI8dhDVKQeLBlAdNh1CxerMEDRiGnr32gdw,2858
-click/_bashcomplete.py,sha256=82rMiibtEurdwBq60NHXVCBuGXJHDpblFO9o2YxJDF0,2423
-click/_compat.py,sha256=j59MpzxYGE-fTGj0A5sg8UI8GhHod1XMojiCA0jvbL0,21011
-click/_termui_impl.py,sha256=Ol1JJhvBRw3l8j1WIU0tOWjQtxxmwGE44lFDbzDqzoA,16395
-click/_textwrap.py,sha256=gwS4m7bdQiJnzaDG8osFcRb-5vn4t4l2qSCy-5csCEc,1198
-click/_unicodefun.py,sha256=A3UOzJw6lEZyol2SBg3fNXgweTutaOzkJ61OB7vik3Y,4204
-click/_winconsole.py,sha256=MzG46DEYPoRyx4SO7EIhFuFZHESgooAfJLIukbB6p5c,7790
-click/core.py,sha256=M0nJ6Kkye7XZXYG7HCbkJWSfy14WHV6bQmGLACrOhKw,70254
-click/decorators.py,sha256=y7CX2needh8iRWafj-QS_hGQFsN24eyXAhx5Y2ATwas,10941
-click/exceptions.py,sha256=rOa0pP3PbSy0_AAPOW9irBEM8AJ3BySN-4z2VUwFVo4,6788
-click/formatting.py,sha256=eh-cypTUAhpI3HD-K4ZpR3vCiURIO62xXvKkR3tNUTM,8889
-click/globals.py,sha256=PAgnKvGxq4YuEIldw3lgYOGBLYwsyxnm1IByBX3BFXo,1515
-click/parser.py,sha256=i01xgYuIA6AwQWEXjshwHSwnTR3gUep4FxJIfyW4ta4,15510
-click/termui.py,sha256=Bp99MSWQtyoWe1_7HggDmA77n--3KLxu7NsZMFMaCUo,21008
-click/testing.py,sha256=kJ9mjtJgwNAlkgKcFf9-ISxufmaPDbbuOHVC9WIvKdY,11002
-click/types.py,sha256=ZGb2lmFs5Vwd9loTRIMbGcqhPVOql8mGoBhWBRT6V4E,18864
-click/utils.py,sha256=1jalPlkUU28JReTEQeeSFtbJd-SirYWBNfjtELBKzT4,14916
-click-6.7.dist-info/DESCRIPTION.rst,sha256=OCTuuN6LcWulhHS3d5rfjdsQtW22n7HENFRh6jC6ego,10
-click-6.7.dist-info/METADATA,sha256=l6lAyogIUXiHKUK_rWguef-EMcvO5C6bXzFCNCcblbQ,424
-click-6.7.dist-info/RECORD,,
-click-6.7.dist-info/WHEEL,sha256=5wvfB7GvgZAbKBSE9uX9Zbi6LCL-_KgezgHblXhCRnM,113
-click-6.7.dist-info/metadata.json,sha256=qg0uO6amNHkIkOxnmWX7Xa_DNQMQ62Q6drivuP9Gh1c,571
-click-6.7.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6
-click-6.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-click/__pycache__/core.cpython-36.pyc,,
-click/__pycache__/decorators.cpython-36.pyc,,
-click/__pycache__/exceptions.cpython-36.pyc,,
-click/__pycache__/formatting.cpython-36.pyc,,
-click/__pycache__/globals.cpython-36.pyc,,
-click/__pycache__/parser.cpython-36.pyc,,
-click/__pycache__/termui.cpython-36.pyc,,
-click/__pycache__/testing.cpython-36.pyc,,
-click/__pycache__/types.cpython-36.pyc,,
-click/__pycache__/utils.cpython-36.pyc,,
-click/__pycache__/_bashcomplete.cpython-36.pyc,,
-click/__pycache__/_compat.cpython-36.pyc,,
-click/__pycache__/_termui_impl.cpython-36.pyc,,
-click/__pycache__/_textwrap.cpython-36.pyc,,
-click/__pycache__/_unicodefun.cpython-36.pyc,,
-click/__pycache__/_winconsole.cpython-36.pyc,,
-click/__pycache__/__init__.cpython-36.pyc,,

website/web/Lib/site-packages/click-6.7.dist-info/WHEEL

@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.30.0.a0)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-

website/web/Lib/site-packages/click-6.7.dist-info/metadata.json

@@ -1 +0,0 @@
-{"classifiers": ["License :: OSI Approved :: BSD License", "Programming Language :: Python", "Programming Language :: Python :: 3"], "extensions": {"python.details": {"contacts": [{"email": "armin.ronacher@active-4.com", "name": "Armin Ronacher", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "http://github.com/mitsuhiko/click"}}}, "generator": "bdist_wheel (0.30.0.a0)", "metadata_version": "2.0", "name": "click", "summary": "A simple wrapper around optparse for powerful command line utilities.", "version": "6.7"}

website/web/Lib/site-packages/click-6.7.dist-info/top_level.txt

@@ -1 +0,0 @@
-click

website/web/Lib/site-packages/click/__init__.py

@@ -1,98 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-    click
-    ~~~~~
-
-    Click is a simple Python module that wraps the stdlib's optparse to make
-    writing command line scripts fun.  Unlike other modules, it's based around
-    a simple API that does not come with too much magic and is composable.
-
-    In case optparse ever gets removed from the stdlib, it will be shipped by
-    this module.
-
-    :copyright: (c) 2014 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-
-# Core classes
-from .core import Context, BaseCommand, Command, MultiCommand, Group, \
-     CommandCollection, Parameter, Option, Argument
-
-# Globals
-from .globals import get_current_context
-
-# Decorators
-from .decorators import pass_context, pass_obj, make_pass_decorator, \
-     command, group, argument, option, confirmation_option, \
-     password_option, version_option, help_option
-
-# Types
-from .types import ParamType, File, Path, Choice, IntRange, Tuple, \
-     STRING, INT, FLOAT, BOOL, UUID, UNPROCESSED
-
-# Utilities
-from .utils import echo, get_binary_stream, get_text_stream, open_file, \
-     format_filename, get_app_dir, get_os_args
-
-# Terminal functions
-from .termui import prompt, confirm, get_terminal_size, echo_via_pager, \
-     progressbar, clear, style, unstyle, secho, edit, launch, getchar, \
-     pause
-
-# Exceptions
-from .exceptions import ClickException, UsageError, BadParameter, \
-     FileError, Abort, NoSuchOption, BadOptionUsage, BadArgumentUsage, \
-     MissingParameter
-
-# Formatting
-from .formatting import HelpFormatter, wrap_text
-
-# Parsing
-from .parser import OptionParser
-
-
-__all__ = [
-    # Core classes
-    'Context', 'BaseCommand', 'Command', 'MultiCommand', 'Group',
-    'CommandCollection', 'Parameter', 'Option', 'Argument',
-
-    # Globals
-    'get_current_context',
-
-    # Decorators
-    'pass_context', 'pass_obj', 'make_pass_decorator', 'command', 'group',
-    'argument', 'option', 'confirmation_option', 'password_option',
-    'version_option', 'help_option',
-
-    # Types
-    'ParamType', 'File', 'Path', 'Choice', 'IntRange', 'Tuple', 'STRING',
-    'INT', 'FLOAT', 'BOOL', 'UUID', 'UNPROCESSED',
-
-    # Utilities
-    'echo', 'get_binary_stream', 'get_text_stream', 'open_file',
-    'format_filename', 'get_app_dir', 'get_os_args',
-
-    # Terminal functions
-    'prompt', 'confirm', 'get_terminal_size', 'echo_via_pager',
-    'progressbar', 'clear', 'style', 'unstyle', 'secho', 'edit', 'launch',
-    'getchar', 'pause',
-
-    # Exceptions
-    'ClickException', 'UsageError', 'BadParameter', 'FileError',
-    'Abort', 'NoSuchOption', 'BadOptionUsage', 'BadArgumentUsage',
-    'MissingParameter',
-
-    # Formatting
-    'HelpFormatter', 'wrap_text',
-
-    # Parsing
-    'OptionParser',
-]
-
-
-# Controls if click should emit the warning about the use of unicode
-# literals.
-disable_unicode_literals_warning = False
-
-
-__version__ = '6.7'

website/web/Lib/site-packages/click/_bashcomplete.py

@@ -1,83 +0,0 @@
-import os
-import re
-from .utils import echo
-from .parser import split_arg_string
-from .core import MultiCommand, Option
-
-
-COMPLETION_SCRIPT = '''
-%(complete_func)s() {
-    COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
-                   COMP_CWORD=$COMP_CWORD \\
-                   %(autocomplete_var)s=complete $1 ) )
-    return 0
-}
-
-complete -F %(complete_func)s -o default %(script_names)s
-'''
-
-_invalid_ident_char_re = re.compile(r'[^a-zA-Z0-9_]')
-
-
-def get_completion_script(prog_name, complete_var):
-    cf_name = _invalid_ident_char_re.sub('', prog_name.replace('-', '_'))
-    return (COMPLETION_SCRIPT % {
-        'complete_func': '_%s_completion' % cf_name,
-        'script_names': prog_name,
-        'autocomplete_var': complete_var,
-    }).strip() + ';'
-
-
-def resolve_ctx(cli, prog_name, args):
-    ctx = cli.make_context(prog_name, args, resilient_parsing=True)
-    while ctx.protected_args + ctx.args and isinstance(ctx.command, MultiCommand):
-        a = ctx.protected_args + ctx.args
-        cmd = ctx.command.get_command(ctx, a[0])
-        if cmd is None:
-            return None
-        ctx = cmd.make_context(a[0], a[1:], parent=ctx, resilient_parsing=True)
-    return ctx
-
-
-def get_choices(cli, prog_name, args, incomplete):
-    ctx = resolve_ctx(cli, prog_name, args)
-    if ctx is None:
-        return
-
-    choices = []
-    if incomplete and not incomplete[:1].isalnum():
-        for param in ctx.command.params:
-            if not isinstance(param, Option):
-                continue
-            choices.extend(param.opts)
-            choices.extend(param.secondary_opts)
-    elif isinstance(ctx.command, MultiCommand):
-        choices.extend(ctx.command.list_commands(ctx))
-
-    for item in choices:
-        if item.startswith(incomplete):
-            yield item
-
-
-def do_complete(cli, prog_name):
-    cwords = split_arg_string(os.environ['COMP_WORDS'])
-    cword = int(os.environ['COMP_CWORD'])
-    args = cwords[1:cword]
-    try:
-        incomplete = cwords[cword]
-    except IndexError:
-        incomplete = ''
-
-    for item in get_choices(cli, prog_name, args, incomplete):
-        echo(item)
-
-    return True
-
-
-def bashcomplete(cli, prog_name, complete_var, complete_instr):
-    if complete_instr == 'source':
-        echo(get_completion_script(prog_name, complete_var))
-        return True
-    elif complete_instr == 'complete':
-        return do_complete(cli, prog_name)
-    return False

website/web/Lib/site-packages/click/_compat.py

@@ -1,648 +0,0 @@
-import re
-import io
-import os
-import sys
-import codecs
-from weakref import WeakKeyDictionary
-
-
-PY2 = sys.version_info[0] == 2
-WIN = sys.platform.startswith('win')
-DEFAULT_COLUMNS = 80
-
-
-_ansi_re = re.compile('\033\[((?:\d|;)*)([a-zA-Z])')
-
-
-def get_filesystem_encoding():
-    return sys.getfilesystemencoding() or sys.getdefaultencoding()
-
-
-def _make_text_stream(stream, encoding, errors):
-    if encoding is None:
-        encoding = get_best_encoding(stream)
-    if errors is None:
-        errors = 'replace'
-    return _NonClosingTextIOWrapper(stream, encoding, errors,
-                                    line_buffering=True)
-
-
-def is_ascii_encoding(encoding):
-    """Checks if a given encoding is ascii."""
-    try:
-        return codecs.lookup(encoding).name == 'ascii'
-    except LookupError:
-        return False
-
-
-def get_best_encoding(stream):
-    """Returns the default stream encoding if not found."""
-    rv = getattr(stream, 'encoding', None) or sys.getdefaultencoding()
-    if is_ascii_encoding(rv):
-        return 'utf-8'
-    return rv
-
-
-class _NonClosingTextIOWrapper(io.TextIOWrapper):
-
-    def __init__(self, stream, encoding, errors, **extra):
-        self._stream = stream = _FixupStream(stream)
-        io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
-
-    # The io module is a place where the Python 3 text behavior
-    # was forced upon Python 2, so we need to unbreak
-    # it to look like Python 2.
-    if PY2:
-        def write(self, x):
-            if isinstance(x, str) or is_bytes(x):
-                try:
-                    self.flush()
-                except Exception:
-                    pass
-                return self.buffer.write(str(x))
-            return io.TextIOWrapper.write(self, x)
-
-        def writelines(self, lines):
-            for line in lines:
-                self.write(line)
-
-    def __del__(self):
-        try:
-            self.detach()
-        except Exception:
-            pass
-
-    def isatty(self):
-        # https://bitbucket.org/pypy/pypy/issue/1803
-        return self._stream.isatty()
-
-
-class _FixupStream(object):
-    """The new io interface needs more from streams than streams
-    traditionally implement.  As such, this fix-up code is necessary in
-    some circumstances.
-    """
-
-    def __init__(self, stream):
-        self._stream = stream
-
-    def __getattr__(self, name):
-        return getattr(self._stream, name)
-
-    def read1(self, size):
-        f = getattr(self._stream, 'read1', None)
-        if f is not None:
-            return f(size)
-        # We only dispatch to readline instead of read in Python 2 as we
-        # do not want cause problems with the different implementation
-        # of line buffering.
-        if PY2:
-            return self._stream.readline(size)
-        return self._stream.read(size)
-
-    def readable(self):
-        x = getattr(self._stream, 'readable', None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.read(0)
-        except Exception:
-            return False
-        return True
-
-    def writable(self):
-        x = getattr(self._stream, 'writable', None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.write('')
-        except Exception:
-            try:
-                self._stream.write(b'')
-            except Exception:
-                return False
-        return True
-
-    def seekable(self):
-        x = getattr(self._stream, 'seekable', None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.seek(self._stream.tell())
-        except Exception:
-            return False
-        return True
-
-
-if PY2:
-    text_type = unicode
-    bytes = str
-    raw_input = raw_input
-    string_types = (str, unicode)
-    iteritems = lambda x: x.iteritems()
-    range_type = xrange
-
-    def is_bytes(x):
-        return isinstance(x, (buffer, bytearray))
-
-    _identifier_re = re.compile(r'^[a-zA-Z_][a-zA-Z0-9_]*$')
-
-    # For Windows, we need to force stdout/stdin/stderr to binary if it's
-    # fetched for that.  This obviously is not the most correct way to do
-    # it as it changes global state.  Unfortunately, there does not seem to
-    # be a clear better way to do it as just reopening the file in binary
-    # mode does not change anything.
-    #
-    # An option would be to do what Python 3 does and to open the file as
-    # binary only, patch it back to the system, and then use a wrapper
-    # stream that converts newlines.  It's not quite clear what's the
-    # correct option here.
-    #
-    # This code also lives in _winconsole for the fallback to the console
-    # emulation stream.
-    #
-    # There are also Windows environments where the `msvcrt` module is not
-    # available (which is why we use try-catch instead of the WIN variable
-    # here), such as the Google App Engine development server on Windows. In
-    # those cases there is just nothing we can do.
-    try:
-        import msvcrt
-    except ImportError:
-        set_binary_mode = lambda x: x
-    else:
-        def set_binary_mode(f):
-            try:
-                fileno = f.fileno()
-            except Exception:
-                pass
-            else:
-                msvcrt.setmode(fileno, os.O_BINARY)
-            return f
-
-    def isidentifier(x):
-        return _identifier_re.search(x) is not None
-
-    def get_binary_stdin():
-        return set_binary_mode(sys.stdin)
-
-    def get_binary_stdout():
-        return set_binary_mode(sys.stdout)
-
-    def get_binary_stderr():
-        return set_binary_mode(sys.stderr)
-
-    def get_text_stdin(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdin, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stdin, encoding, errors)
-
-    def get_text_stdout(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdout, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stdout, encoding, errors)
-
-    def get_text_stderr(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stderr, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stderr, encoding, errors)
-
-    def filename_to_ui(value):
-        if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), 'replace')
-        return value
-else:
-    import io
-    text_type = str
-    raw_input = input
-    string_types = (str,)
-    range_type = range
-    isidentifier = lambda x: x.isidentifier()
-    iteritems = lambda x: iter(x.items())
-
-    def is_bytes(x):
-        return isinstance(x, (bytes, memoryview, bytearray))
-
-    def _is_binary_reader(stream, default=False):
-        try:
-            return isinstance(stream.read(0), bytes)
-        except Exception:
-            return default
-            # This happens in some cases where the stream was already
-            # closed.  In this case, we assume the default.
-
-    def _is_binary_writer(stream, default=False):
-        try:
-            stream.write(b'')
-        except Exception:
-            try:
-                stream.write('')
-                return False
-            except Exception:
-                pass
-            return default
-        return True
-
-    def _find_binary_reader(stream):
-        # We need to figure out if the given stream is already binary.
-        # This can happen because the official docs recommend detaching
-        # the streams to get binary streams.  Some code might do this, so
-        # we need to deal with this case explicitly.
-        if _is_binary_reader(stream, False):
-            return stream
-
-        buf = getattr(stream, 'buffer', None)
-
-        # Same situation here; this time we assume that the buffer is
-        # actually binary in case it's closed.
-        if buf is not None and _is_binary_reader(buf, True):
-            return buf
-
-    def _find_binary_writer(stream):
-        # We need to figure out if the given stream is already binary.
-        # This can happen because the official docs recommend detatching
-        # the streams to get binary streams.  Some code might do this, so
-        # we need to deal with this case explicitly.
-        if _is_binary_writer(stream, False):
-            return stream
-
-        buf = getattr(stream, 'buffer', None)
-
-        # Same situation here; this time we assume that the buffer is
-        # actually binary in case it's closed.
-        if buf is not None and _is_binary_writer(buf, True):
-            return buf
-
-    def _stream_is_misconfigured(stream):
-        """A stream is misconfigured if its encoding is ASCII."""
-        # If the stream does not have an encoding set, we assume it's set
-        # to ASCII.  This appears to happen in certain unittest
-        # environments.  It's not quite clear what the correct behavior is
-        # but this at least will force Click to recover somehow.
-        return is_ascii_encoding(getattr(stream, 'encoding', None) or 'ascii')
-
-    def _is_compatible_text_stream(stream, encoding, errors):
-        stream_encoding = getattr(stream, 'encoding', None)
-        stream_errors = getattr(stream, 'errors', None)
-
-        # Perfect match.
-        if stream_encoding == encoding and stream_errors == errors:
-            return True
-
-        # Otherwise, it's only a compatible stream if we did not ask for
-        # an encoding.
-        if encoding is None:
-            return stream_encoding is not None
-
-        return False
-
-    def _force_correct_text_reader(text_reader, encoding, errors):
-        if _is_binary_reader(text_reader, False):
-            binary_reader = text_reader
-        else:
-            # If there is no target encoding set, we need to verify that the
-            # reader is not actually misconfigured.
-            if encoding is None and not _stream_is_misconfigured(text_reader):
-                return text_reader
-
-            if _is_compatible_text_stream(text_reader, encoding, errors):
-                return text_reader
-
-            # If the reader has no encoding, we try to find the underlying
-            # binary reader for it.  If that fails because the environment is
-            # misconfigured, we silently go with the same reader because this
-            # is too common to happen.  In that case, mojibake is better than
-            # exceptions.
-            binary_reader = _find_binary_reader(text_reader)
-            if binary_reader is None:
-                return text_reader
-
-        # At this point, we default the errors to replace instead of strict
-        # because nobody handles those errors anyways and at this point
-        # we're so fundamentally fucked that nothing can repair it.
-        if errors is None:
-            errors = 'replace'
-        return _make_text_stream(binary_reader, encoding, errors)
-
-    def _force_correct_text_writer(text_writer, encoding, errors):
-        if _is_binary_writer(text_writer, False):
-            binary_writer = text_writer
-        else:
-            # If there is no target encoding set, we need to verify that the
-            # writer is not actually misconfigured.
-            if encoding is None and not _stream_is_misconfigured(text_writer):
-                return text_writer
-
-            if _is_compatible_text_stream(text_writer, encoding, errors):
-                return text_writer
-
-            # If the writer has no encoding, we try to find the underlying
-            # binary writer for it.  If that fails because the environment is
-            # misconfigured, we silently go with the same writer because this
-            # is too common to happen.  In that case, mojibake is better than
-            # exceptions.
-            binary_writer = _find_binary_writer(text_writer)
-            if binary_writer is None:
-                return text_writer
-
-        # At this point, we default the errors to replace instead of strict
-        # because nobody handles those errors anyways and at this point
-        # we're so fundamentally fucked that nothing can repair it.
-        if errors is None:
-            errors = 'replace'
-        return _make_text_stream(binary_writer, encoding, errors)
-
-    def get_binary_stdin():
-        reader = _find_binary_reader(sys.stdin)
-        if reader is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stdin.')
-        return reader
-
-    def get_binary_stdout():
-        writer = _find_binary_writer(sys.stdout)
-        if writer is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stdout.')
-        return writer
-
-    def get_binary_stderr():
-        writer = _find_binary_writer(sys.stderr)
-        if writer is None:
-            raise RuntimeError('Was not able to determine binary '
-                               'stream for sys.stderr.')
-        return writer
-
-    def get_text_stdin(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdin, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_reader(sys.stdin, encoding, errors)
-
-    def get_text_stdout(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdout, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_writer(sys.stdout, encoding, errors)
-
-    def get_text_stderr(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stderr, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_writer(sys.stderr, encoding, errors)
-
-    def filename_to_ui(value):
-        if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), 'replace')
-        else:
-            value = value.encode('utf-8', 'surrogateescape') \
-                .decode('utf-8', 'replace')
-        return value
-
-
-def get_streerror(e, default=None):
-    if hasattr(e, 'strerror'):
-        msg = e.strerror
-    else:
-        if default is not None:
-            msg = default
-        else:
-            msg = str(e)
-    if isinstance(msg, bytes):
-        msg = msg.decode('utf-8', 'replace')
-    return msg
-
-
-def open_stream(filename, mode='r', encoding=None, errors='strict',
-                atomic=False):
-    # Standard streams first.  These are simple because they don't need
-    # special handling for the atomic flag.  It's entirely ignored.
-    if filename == '-':
-        if 'w' in mode:
-            if 'b' in mode:
-                return get_binary_stdout(), False
-            return get_text_stdout(encoding=encoding, errors=errors), False
-        if 'b' in mode:
-            return get_binary_stdin(), False
-        return get_text_stdin(encoding=encoding, errors=errors), False
-
-    # Non-atomic writes directly go out through the regular open functions.
-    if not atomic:
-        if encoding is None:
-            return open(filename, mode), True
-        return io.open(filename, mode, encoding=encoding, errors=errors), True
-
-    # Some usability stuff for atomic writes
-    if 'a' in mode:
-        raise ValueError(
-            'Appending to an existing file is not supported, because that '
-            'would involve an expensive `copy`-operation to a temporary '
-            'file. Open the file in normal `w`-mode and copy explicitly '
-            'if that\'s what you\'re after.'
-        )
-    if 'x' in mode:
-        raise ValueError('Use the `overwrite`-parameter instead.')
-    if 'w' not in mode:
-        raise ValueError('Atomic writes only make sense with `w`-mode.')
-
-    # Atomic writes are more complicated.  They work by opening a file
-    # as a proxy in the same folder and then using the fdopen
-    # functionality to wrap it in a Python file.  Then we wrap it in an
-    # atomic file that moves the file over on close.
-    import tempfile
-    fd, tmp_filename = tempfile.mkstemp(dir=os.path.dirname(filename),
-                                        prefix='.__atomic-write')
-
-    if encoding is not None:
-        f = io.open(fd, mode, encoding=encoding, errors=errors)
-    else:
-        f = os.fdopen(fd, mode)
-
-    return _AtomicFile(f, tmp_filename, filename), True
-
-
-# Used in a destructor call, needs extra protection from interpreter cleanup.
-if hasattr(os, 'replace'):
-    _replace = os.replace
-    _can_replace = True
-else:
-    _replace = os.rename
-    _can_replace = not WIN
-
-
-class _AtomicFile(object):
-
-    def __init__(self, f, tmp_filename, real_filename):
-        self._f = f
-        self._tmp_filename = tmp_filename
-        self._real_filename = real_filename
-        self.closed = False
-
-    @property
-    def name(self):
-        return self._real_filename
-
-    def close(self, delete=False):
-        if self.closed:
-            return
-        self._f.close()
-        if not _can_replace:
-            try:
-                os.remove(self._real_filename)
-            except OSError:
-                pass
-        _replace(self._tmp_filename, self._real_filename)
-        self.closed = True
-
-    def __getattr__(self, name):
-        return getattr(self._f, name)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close(delete=exc_type is not None)
-
-    def __repr__(self):
-        return repr(self._f)
-
-
-auto_wrap_for_ansi = None
-colorama = None
-get_winterm_size = None
-
-
-def strip_ansi(value):
-    return _ansi_re.sub('', value)
-
-
-def should_strip_ansi(stream=None, color=None):
-    if color is None:
-        if stream is None:
-            stream = sys.stdin
-        return not isatty(stream)
-    return not color
-
-
-# If we're on Windows, we provide transparent integration through
-# colorama.  This will make ANSI colors through the echo function
-# work automatically.
-if WIN:
-    # Windows has a smaller terminal
-    DEFAULT_COLUMNS = 79
-
-    from ._winconsole import _get_windows_console_stream
-
-    def _get_argv_encoding():
-        import locale
-        return locale.getpreferredencoding()
-
-    if PY2:
-        def raw_input(prompt=''):
-            sys.stderr.flush()
-            if prompt:
-                stdout = _default_text_stdout()
-                stdout.write(prompt)
-            stdin = _default_text_stdin()
-            return stdin.readline().rstrip('\r\n')
-
-    try:
-        import colorama
-    except ImportError:
-        pass
-    else:
-        _ansi_stream_wrappers = WeakKeyDictionary()
-
-        def auto_wrap_for_ansi(stream, color=None):
-            """This function wraps a stream so that calls through colorama
-            are issued to the win32 console API to recolor on demand.  It
-            also ensures to reset the colors if a write call is interrupted
-            to not destroy the console afterwards.
-            """
-            try:
-                cached = _ansi_stream_wrappers.get(stream)
-            except Exception:
-                cached = None
-            if cached is not None:
-                return cached
-            strip = should_strip_ansi(stream, color)
-            ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
-            rv = ansi_wrapper.stream
-            _write = rv.write
-
-            def _safe_write(s):
-                try:
-                    return _write(s)
-                except:
-                    ansi_wrapper.reset_all()
-                    raise
-
-            rv.write = _safe_write
-            try:
-                _ansi_stream_wrappers[stream] = rv
-            except Exception:
-                pass
-            return rv
-
-        def get_winterm_size():
-            win = colorama.win32.GetConsoleScreenBufferInfo(
-                colorama.win32.STDOUT).srWindow
-            return win.Right - win.Left, win.Bottom - win.Top
-else:
-    def _get_argv_encoding():
-        return getattr(sys.stdin, 'encoding', None) or get_filesystem_encoding()
-
-    _get_windows_console_stream = lambda *x: None
-
-
-def term_len(x):
-    return len(strip_ansi(x))
-
-
-def isatty(stream):
-    try:
-        return stream.isatty()
-    except Exception:
-        return False
-
-
-def _make_cached_stream_func(src_func, wrapper_func):
-    cache = WeakKeyDictionary()
-    def func():
-        stream = src_func()
-        try:
-            rv = cache.get(stream)
-        except Exception:
-            rv = None
-        if rv is not None:
-            return rv
-        rv = wrapper_func()
-        try:
-            cache[stream] = rv
-        except Exception:
-            pass
-        return rv
-    return func
-
-
-_default_text_stdin = _make_cached_stream_func(
-    lambda: sys.stdin, get_text_stdin)
-_default_text_stdout = _make_cached_stream_func(
-    lambda: sys.stdout, get_text_stdout)
-_default_text_stderr = _make_cached_stream_func(
-    lambda: sys.stderr, get_text_stderr)
-
-
-binary_streams = {
-    'stdin': get_binary_stdin,
-    'stdout': get_binary_stdout,
-    'stderr': get_binary_stderr,
-}
-
-text_streams = {
-    'stdin': get_text_stdin,
-    'stdout': get_text_stdout,
-    'stderr': get_text_stderr,
-}

website/web/Lib/site-packages/click/_termui_impl.py

@@ -1,547 +0,0 @@
-"""
-    click._termui_impl
-    ~~~~~~~~~~~~~~~~~~
-
-    This module contains implementations for the termui module.  To keep the
-    import time of Click down, some infrequently used functionality is placed
-    in this module and only imported as needed.
-
-    :copyright: (c) 2014 by Armin Ronacher.
-    :license: BSD, see LICENSE for more details.
-"""
-import os
-import sys
-import time
-import math
-from ._compat import _default_text_stdout, range_type, PY2, isatty, \
-     open_stream, strip_ansi, term_len, get_best_encoding, WIN
-from .utils import echo
-from .exceptions import ClickException
-
-
-if os.name == 'nt':
-    BEFORE_BAR = '\r'
-    AFTER_BAR = '\n'
-else:
-    BEFORE_BAR = '\r\033[?25l'
-    AFTER_BAR = '\033[?25h\n'
-
-
-def _length_hint(obj):
-    """Returns the length hint of an object."""
-    try:
-        return len(obj)
-    except (AttributeError, TypeError):
-        try:
-            get_hint = type(obj).__length_hint__
-        except AttributeError:
-            return None
-        try:
-            hint = get_hint(obj)
-        except TypeError:
-            return None
-        if hint is NotImplemented or \
-           not isinstance(hint, (int, long)) or \
-           hint < 0:
-            return None
-        return hint
-
-
-class ProgressBar(object):
-
-    def __init__(self, iterable, length=None, fill_char='#', empty_char=' ',
-                 bar_template='%(bar)s', info_sep='  ', show_eta=True,
-                 show_percent=None, show_pos=False, item_show_func=None,
-                 label=None, file=None, color=None, width=30):
-        self.fill_char = fill_char
-        self.empty_char = empty_char
-        self.bar_template = bar_template
-        self.info_sep = info_sep
-        self.show_eta = show_eta
-        self.show_percent = show_percent
-        self.show_pos = show_pos
-        self.item_show_func = item_show_func
-        self.label = label or ''
-        if file is None:
-            file = _default_text_stdout()
-        self.file = file
-        self.color = color
-        self.width = width
-        self.autowidth = width == 0
-
-        if length is None:
-            length = _length_hint(iterable)
-        if iterable is None:
-            if length is None:
-                raise TypeError('iterable or length is required')
-            iterable = range_type(length)
-        self.iter = iter(iterable)
-        self.length = length
-        self.length_known = length is not None
-        self.pos = 0
-        self.avg = []
-        self.start = self.last_eta = time.time()
-        self.eta_known = False
-        self.finished = False
-        self.max_width = None
-        self.entered = False
-        self.current_item = None
-        self.is_hidden = not isatty(self.file)
-        self._last_line = None
-
-    def __enter__(self):
-        self.entered = True
-        self.render_progress()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.render_finish()
-
-    def __iter__(self):
-        if not self.entered:
-            raise RuntimeError('You need to use progress bars in a with block.')
-        self.render_progress()
-        return self
-
-    def render_finish(self):
-        if self.is_hidden:
-            return
-        self.file.write(AFTER_BAR)
-        self.file.flush()
-
-    @property
-    def pct(self):
-        if self.finished:
-            return 1.0
-        return min(self.pos / (float(self.length) or 1), 1.0)
-
-    @property
-    def time_per_iteration(self):
-        if not self.avg:
-            return 0.0
-        return sum(self.avg) / float(len(self.avg))
-
-    @property
-    def eta(self):
-        if self.length_known and not self.finished:
-            return self.time_per_iteration * (self.length - self.pos)
-        return 0.0
-
-    def format_eta(self):
-        if self.eta_known:
-            t = self.eta + 1
-            seconds = t % 60
-            t /= 60
-            minutes = t % 60
-            t /= 60
-            hours = t % 24
-            t /= 24
-            if t > 0:
-                days = t
-                return '%dd %02d:%02d:%02d' % (days, hours, minutes, seconds)
-            else:
-                return '%02d:%02d:%02d' % (hours, minutes, seconds)
-        return ''
-
-    def format_pos(self):
-        pos = str(self.pos)
-        if self.length_known:
-            pos += '/%s' % self.length
-        return pos
-
-    def format_pct(self):
-        return ('% 4d%%' % int(self.pct * 100))[1:]
-
-    def format_progress_line(self):
-        show_percent = self.show_percent
-
-        info_bits = []
-        if self.length_known:
-            bar_length = int(self.pct * self.width)
-            bar = self.fill_char * bar_length
-            bar += self.empty_char * (self.width - bar_length)
-            if show_percent is None:
-                show_percent = not self.show_pos
-        else:
-            if self.finished:
-                bar = self.fill_char * self.width
-            else:
-                bar = list(self.empty_char * (self.width or 1))
-                if self.time_per_iteration != 0:
-                    bar[int((math.cos(self.pos * self.time_per_iteration)
-                        / 2.0 + 0.5) * self.width)] = self.fill_char
-                bar = ''.join(bar)
-
-        if self.show_pos:
-            info_bits.append(self.format_pos())
-        if show_percent:
-            info_bits.append(self.format_pct())
-        if self.show_eta and self.eta_known and not self.finished:
-            info_bits.append(self.format_eta())
-        if self.item_show_func is not None:
-            item_info = self.item_show_func(self.current_item)
-            if item_info is not None:
-                info_bits.append(item_info)
-
-        return (self.bar_template % {
-            'label': self.label,
-            'bar': bar,
-            'info': self.info_sep.join(info_bits)
-        }).rstrip()
-
-    def render_progress(self):
-        from .termui import get_terminal_size
-        nl = False
-
-        if self.is_hidden:
-            buf = [self.label]
-            nl = True
-        else:
-            buf = []
-            # Update width in case the terminal has been resized
-            if self.autowidth:
-                old_width = self.width
-                self.width = 0
-                clutter_length = term_len(self.format_progress_line())
-                new_width = max(0, get_terminal_size()[0] - clutter_length)
-                if new_width < old_width:
-                    buf.append(BEFORE_BAR)
-                    buf.append(' ' * self.max_width)
-                    self.max_width = new_width
-                self.width = new_width
-
-            clear_width = self.width
-            if self.max_width is not None:
-                clear_width = self.max_width
-
-            buf.append(BEFORE_BAR)
-            line = self.format_progress_line()
-            line_len = term_len(line)
-            if self.max_width is None or self.max_width < line_len:
-                self.max_width = line_len
-            buf.append(line)
-
-            buf.append(' ' * (clear_width - line_len))
-        line = ''.join(buf)
-
-        # Render the line only if it changed.
-        if line != self._last_line:
-            self._last_line = line
-            echo(line, file=self.file, color=self.color, nl=nl)
-            self.file.flush()
-
-    def make_step(self, n_steps):
-        self.pos += n_steps
-        if self.length_known and self.pos >= self.length:
-            self.finished = True
-
-        if (time.time() - self.last_eta) < 1.0:
-            return
-
-        self.last_eta = time.time()
-        self.avg = self.avg[-6:] + [-(self.start - time.time()) / (self.pos)]
-
-        self.eta_known = self.length_known
-
-    def update(self, n_steps):
-        self.make_step(n_steps)
-        self.render_progress()
-
-    def finish(self):
-        self.eta_known = 0
-        self.current_item = None
-        self.finished = True
-
-    def next(self):
-        if self.is_hidden:
-            return next(self.iter)
-        try:
-            rv = next(self.iter)
-            self.current_item = rv
-        except StopIteration:
-            self.finish()
-            self.render_progress()
-            raise StopIteration()
-        else:
-            self.update(1)
-            return rv
-
-    if not PY2:
-        __next__ = next
-        del next
-
-
-def pager(text, color=None):
-    """Decide what method to use for paging through text."""
-    stdout = _default_text_stdout()
-    if not isatty(sys.stdin) or not isatty(stdout):
-        return _nullpager(stdout, text, color)
-    pager_cmd = (os.environ.get('PAGER', None) or '').strip()
-    if pager_cmd:
-        if WIN:
-            return _tempfilepager(text, pager_cmd, color)
-        return _pipepager(text, pager_cmd, color)
-    if os.environ.get('TERM') in ('dumb', 'emacs'):
-        return _nullpager(stdout, text, color)
-    if WIN or sys.platform.startswith('os2'):
-        return _tempfilepager(text, 'more <', color)
-    if hasattr(os, 'system') and os.system('(less) 2>/dev/null') == 0:
-        return _pipepager(text, 'less', color)
-
-    import tempfile
-    fd, filename = tempfile.mkstemp()
-    os.close(fd)
-    try:
-        if hasattr(os, 'system') and os.system('more "%s"' % filename) == 0:
-            return _pipepager(text, 'more', color)
-        return _nullpager(stdout, text, color)
-    finally:
-        os.unlink(filename)
-
-
-def _pipepager(text, cmd, color):
-    """Page through text by feeding it to another program.  Invoking a
-    pager through this might support colors.
-    """
-    import subprocess
-    env = dict(os.environ)
-
-    # If we're piping to less we might support colors under the
-    # condition that
-    cmd_detail = cmd.rsplit('/', 1)[-1].split()
-    if color is None and cmd_detail[0] == 'less':
-        less_flags = os.environ.get('LESS', '') + ' '.join(cmd_detail[1:])
-        if not less_flags:
-            env['LESS'] = '-R'
-            color = True
-        elif 'r' in less_flags or 'R' in less_flags:
-            color = True
-
-    if not color:
-        text = strip_ansi(text)
-
-    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,
-                         env=env)
-    encoding = get_best_encoding(c.stdin)
-    try:
-        c.stdin.write(text.encode(encoding, 'replace'))
-        c.stdin.close()
-    except (IOError, KeyboardInterrupt):
-        pass
-
-    # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
-    # search or other commands inside less).
-    #
-    # That means when the user hits ^C, the parent process (click) terminates,
-    # but less is still alive, paging the output and messing up the terminal.
-    #
-    # If the user wants to make the pager exit on ^C, they should set
-    # `LESS='-K'`. It's not our decision to make.
-    while True:
-        try:
-            c.wait()
-        except KeyboardInterrupt:
-            pass
-        else:
-            break
-
-
-def _tempfilepager(text, cmd, color):
-    """Page through text by invoking a program on a temporary file."""
-    import tempfile
-    filename = tempfile.mktemp()
-    if not color:
-        text = strip_ansi(text)
-    encoding = get_best_encoding(sys.stdout)
-    with open_stream(filename, 'wb')[0] as f:
-        f.write(text.encode(encoding))
-    try:
-        os.system(cmd + ' "' + filename + '"')
-    finally:
-        os.unlink(filename)
-
-
-def _nullpager(stream, text, color):
-    """Simply print unformatted text.  This is the ultimate fallback."""
-    if not color:
-        text = strip_ansi(text)
-    stream.write(text)
-
-
-class Editor(object):
-
-    def __init__(self, editor=None, env=None, require_save=True,
-                 extension='.txt'):
-        self.editor = editor
-        self.env = env
-        self.require_save = require_save
-        self.extension = extension
-
-    def get_editor(self):
-        if self.editor is not None:
-            return self.editor
-        for key in 'VISUAL', 'EDITOR':
-            rv = os.environ.get(key)
-            if rv:
-                return rv
-        if WIN:
-            return 'notepad'
-        for editor in 'vim', 'nano':
-            if os.system('which %s >/dev/null 2>&1' % editor) == 0:
-                return editor
-        return 'vi'
-
-    def edit_file(self, filename):
-        import subprocess
-        editor = self.get_editor()
-        if self.env:
-            environ = os.environ.copy()
-            environ.update(self.env)
-        else:
-            environ = None
-        try:
-            c = subprocess.Popen('%s "%s"' % (editor, filename),
-                                 env=environ, shell=True)
-            exit_code = c.wait()
-            if exit_code != 0:
-                raise ClickException('%s: Editing failed!' % editor)
-        except OSError as e:
-            raise ClickException('%s: Editing failed: %s' % (editor, e))
-
-    def edit(self, text):
-        import tempfile
-
-        text = text or ''
-        if text and not text.endswith('\n'):
-            text += '\n'
-
-        fd, name = tempfile.mkstemp(prefix='editor-', suffix=self.extension)
-        try:
-            if WIN:
-                encoding = 'utf-8-sig'
-                text = text.replace('\n', '\r\n')
-            else:
-                encoding = 'utf-8'
-            text = text.encode(encoding)
-
-            f = os.fdopen(fd, 'wb')
-            f.write(text)
-            f.close()
-            timestamp = os.path.getmtime(name)
-
-            self.edit_file(name)
-
-            if self.require_save \
-               and os.path.getmtime(name) == timestamp:
-                return None
-
-            f = open(name, 'rb')
-            try:
-                rv = f.read()
-            finally:
-                f.close()
-            return rv.decode('utf-8-sig').replace('\r\n', '\n')
-        finally:
-            os.unlink(name)
-
-
-def open_url(url, wait=False, locate=False):
-    import subprocess
-
-    def _unquote_file(url):
-        try:
-            import urllib
-        except ImportError:
-            import urllib
-        if url.startswith('file://'):
-            url = urllib.unquote(url[7:])
-        return url
-
-    if sys.platform == 'darwin':
-        args = ['open']
-        if wait:
-            args.append('-W')
-        if locate:
-            args.append('-R')
-        args.append(_unquote_file(url))
-        null = open('/dev/null', 'w')
-        try:
-            return subprocess.Popen(args, stderr=null).wait()
-        finally:
-            null.close()
-    elif WIN:
-        if locate:
-            url = _unquote_file(url)
-            args = 'explorer /select,"%s"' % _unquote_file(
-                url.replace('"', ''))
-        else:
-            args = 'start %s "" "%s"' % (
-                wait and '/WAIT' or '', url.replace('"', ''))
-        return os.system(args)
-
-    try:
-        if locate:
-            url = os.path.dirname(_unquote_file(url)) or '.'
-        else:
-            url = _unquote_file(url)
-        c = subprocess.Popen(['xdg-open', url])
-        if wait:
-            return c.wait()
-        return 0
-    except OSError:
-        if url.startswith(('http://', 'https://')) and not locate and not wait:
-            import webbrowser
-            webbrowser.open(url)
-            return 0
-        return 1
-
-
-def _translate_ch_to_exc(ch):
-    if ch == '\x03':
-        raise KeyboardInterrupt()
-    if ch == '\x04':
-        raise EOFError()
-
-
-if WIN:
-    import msvcrt
-
-    def getchar(echo):
-        rv = msvcrt.getch()
-        if echo:
-            msvcrt.putchar(rv)
-        _translate_ch_to_exc(rv)
-        if PY2:
-            enc = getattr(sys.stdin, 'encoding', None)
-            if enc is not None:
-                rv = rv.decode(enc, 'replace')
-            else:
-                rv = rv.decode('cp1252', 'replace')
-        return rv
-else:
-    import tty
-    import termios
-
-    def getchar(echo):
-        if not isatty(sys.stdin):
-            f = open('/dev/tty')
-            fd = f.fileno()
-        else:
-            fd = sys.stdin.fileno()
-            f = None
-        try:
-            old_settings = termios.tcgetattr(fd)
-            try:
-                tty.setraw(fd)
-                ch = os.read(fd, 32)
-                if echo and isatty(sys.stdout):
-                    sys.stdout.write(ch)
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-                sys.stdout.flush()
-                if f is not None:
-                    f.close()
-        except termios.error:
-            pass
-        _translate_ch_to_exc(ch)
-        return ch.decode(get_best_encoding(sys.stdin), 'replace')

website/web/Lib/site-packages/click/_textwrap.py

@@ -1,38 +0,0 @@
-import textwrap
-from contextlib import contextmanager
-
-
-class TextWrapper(textwrap.TextWrapper):
-
-    def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
-        space_left = max(width - cur_len, 1)
-
-        if self.break_long_words:
-            last = reversed_chunks[-1]
-            cut = last[:space_left]
-            res = last[space_left:]
-            cur_line.append(cut)
-            reversed_chunks[-1] = res
-        elif not cur_line:
-            cur_line.append(reversed_chunks.pop())
-
-    @contextmanager
-    def extra_indent(self, indent):
-        old_initial_indent = self.initial_indent
-        old_subsequent_indent = self.subsequent_indent
-        self.initial_indent += indent
-        self.subsequent_indent += indent
-        try:
-            yield
-        finally:
-            self.initial_indent = old_initial_indent
-            self.subsequent_indent = old_subsequent_indent
-
-    def indent_only(self, text):
-        rv = []
-        for idx, line in enumerate(text.splitlines()):
-            indent = self.initial_indent
-            if idx > 0:
-                indent = self.subsequent_indent
-            rv.append(indent + line)
-        return '\n'.join(rv)

website/web/Lib/site-packages/click/_unicodefun.py

@@ -1,118 +0,0 @@
-import os
-import sys
-import codecs
-
-from ._compat import PY2
-
-
-# If someone wants to vendor click, we want to ensure the
-# correct package is discovered.  Ideally we could use a
-# relative import here but unfortunately Python does not
-# support that.
-click = sys.modules[__name__.rsplit('.', 1)[0]]
-
-
-def _find_unicode_literals_frame():
-    import __future__
-    frm = sys._getframe(1)
-    idx = 1
-    while frm is not None:
-        if frm.f_globals.get('__name__', '').startswith('click.'):
-            frm = frm.f_back
-            idx += 1
-        elif frm.f_code.co_flags & __future__.unicode_literals.compiler_flag:
-            return idx
-        else:
-            break
-    return 0
-
-
-def _check_for_unicode_literals():
-    if not __debug__:
-        return
-    if not PY2 or click.disable_unicode_literals_warning:
-        return
-    bad_frame = _find_unicode_literals_frame()
-    if bad_frame <= 0:
-        return
-    from warnings import warn
-    warn(Warning('Click detected the use of the unicode_literals '
-                 '__future__ import.  This is heavily discouraged '
-                 'because it can introduce subtle bugs in your '
-                 'code.  You should instead use explicit u"" literals '
-                 'for your unicode strings.  For more information see '
-                 'http://click.pocoo.org/python3/'),
-         stacklevel=bad_frame)
-
-
-def _verify_python3_env():
-    """Ensures that the environment is good for unicode on Python 3."""
-    if PY2:
-        return
-    try:
-        import locale
-        fs_enc = codecs.lookup(locale.getpreferredencoding()).name
-    except Exception:
-        fs_enc = 'ascii'
-    if fs_enc != 'ascii':
-        return
-
-    extra = ''
-    if os.name == 'posix':
-        import subprocess
-        rv = subprocess.Popen(['locale', '-a'], stdout=subprocess.PIPE,
-                              stderr=subprocess.PIPE).communicate()[0]
-        good_locales = set()
-        has_c_utf8 = False
-
-        # Make sure we're operating on text here.
-        if isinstance(rv, bytes):
-            rv = rv.decode('ascii', 'replace')
-
-        for line in rv.splitlines():
-            locale = line.strip()
-            if locale.lower().endswith(('.utf-8', '.utf8')):
-                good_locales.add(locale)
-                if locale.lower() in ('c.utf8', 'c.utf-8'):
-                    has_c_utf8 = True
-
-        extra += '\n\n'
-        if not good_locales:
-            extra += (
-                'Additional information: on this system no suitable UTF-8\n'
-                'locales were discovered.  This most likely requires resolving\n'
-                'by reconfiguring the locale system.'
-            )
-        elif has_c_utf8:
-            extra += (
-                'This system supports the C.UTF-8 locale which is recommended.\n'
-                'You might be able to resolve your issue by exporting the\n'
-                'following environment variables:\n\n'
-                '    export LC_ALL=C.UTF-8\n'
-                '    export LANG=C.UTF-8'
-            )
-        else:
-            extra += (
-                'This system lists a couple of UTF-8 supporting locales that\n'
-                'you can pick from.  The following suitable locales where\n'
-                'discovered: %s'
-            ) % ', '.join(sorted(good_locales))
-
-        bad_locale = None
-        for locale in os.environ.get('LC_ALL'), os.environ.get('LANG'):
-            if locale and locale.lower().endswith(('.utf-8', '.utf8')):
-                bad_locale = locale
-            if locale is not None:
-                break
-        if bad_locale is not None:
-            extra += (
-                '\n\nClick discovered that you exported a UTF-8 locale\n'
-                'but the locale system could not pick up from it because\n'
-                'it does not exist.  The exported locale is "%s" but it\n'
-                'is not supported'
-            ) % bad_locale
-
-    raise RuntimeError('Click will abort further execution because Python 3 '
-                       'was configured to use ASCII as encoding for the '
-                       'environment.  Consult http://click.pocoo.org/python3/'
-                       'for mitigation steps.' + extra)

website/web/Lib/site-packages/click/_winconsole.py

@@ -1,273 +0,0 @@
-# -*- coding: utf-8 -*-
-# This module is based on the excellent work by Adam Bartoš who
-# provided a lot of what went into the implementation here in
-# the discussion to issue1602 in the Python bug tracker.
-#
-# There are some general differences in regards to how this works
-# compared to the original patches as we do not need to patch
-# the entire interpreter but just work in our little world of
-# echo and prmopt.
-
-import io
-import os
-import sys
-import zlib
-import time
-import ctypes
-import msvcrt
-from click._compat import _NonClosingTextIOWrapper, text_type, PY2
-from ctypes import byref, POINTER, c_int, c_char, c_char_p, \
-     c_void_p, py_object, c_ssize_t, c_ulong, windll, WINFUNCTYPE
-try:
-    from ctypes import pythonapi
-    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
-    PyBuffer_Release = pythonapi.PyBuffer_Release
-except ImportError:
-    pythonapi = None
-from ctypes.wintypes import LPWSTR, LPCWSTR
-
-
-c_ssize_p = POINTER(c_ssize_t)
-
-kernel32 = windll.kernel32
-GetStdHandle = kernel32.GetStdHandle
-ReadConsoleW = kernel32.ReadConsoleW
-WriteConsoleW = kernel32.WriteConsoleW
-GetLastError = kernel32.GetLastError
-GetCommandLineW = WINFUNCTYPE(LPWSTR)(
-    ('GetCommandLineW', windll.kernel32))
-CommandLineToArgvW = WINFUNCTYPE(
-    POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
-        ('CommandLineToArgvW', windll.shell32))
-
-
-STDIN_HANDLE = GetStdHandle(-10)
-STDOUT_HANDLE = GetStdHandle(-11)
-STDERR_HANDLE = GetStdHandle(-12)
-
-
-PyBUF_SIMPLE = 0
-PyBUF_WRITABLE = 1
-
-ERROR_SUCCESS = 0
-ERROR_NOT_ENOUGH_MEMORY = 8
-ERROR_OPERATION_ABORTED = 995
-
-STDIN_FILENO = 0
-STDOUT_FILENO = 1
-STDERR_FILENO = 2
-
-EOF = b'\x1a'
-MAX_BYTES_WRITTEN = 32767
-
-
-class Py_buffer(ctypes.Structure):
-    _fields_ = [
-        ('buf', c_void_p),
-        ('obj', py_object),
-        ('len', c_ssize_t),
-        ('itemsize', c_ssize_t),
-        ('readonly', c_int),
-        ('ndim', c_int),
-        ('format', c_char_p),
-        ('shape', c_ssize_p),
-        ('strides', c_ssize_p),
-        ('suboffsets', c_ssize_p),
-        ('internal', c_void_p)
-    ]
-
-    if PY2:
-        _fields_.insert(-1, ('smalltable', c_ssize_t * 2))
-
-
-# On PyPy we cannot get buffers so our ability to operate here is
-# serverly limited.
-if pythonapi is None:
-    get_buffer = None
-else:
-    def get_buffer(obj, writable=False):
-        buf = Py_buffer()
-        flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
-        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
-        try:
-            buffer_type = c_char * buf.len
-            return buffer_type.from_address(buf.buf)
-        finally:
-            PyBuffer_Release(byref(buf))
-
-
-class _WindowsConsoleRawIOBase(io.RawIOBase):
-
-    def __init__(self, handle):
-        self.handle = handle
-
-    def isatty(self):
-        io.RawIOBase.isatty(self)
-        return True
-
-
-class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
-
-    def readable(self):
-        return True
-
-    def readinto(self, b):
-        bytes_to_be_read = len(b)
-        if not bytes_to_be_read:
-            return 0
-        elif bytes_to_be_read % 2:
-            raise ValueError('cannot read odd number of bytes from '
-                             'UTF-16-LE encoded console')
-
-        buffer = get_buffer(b, writable=True)
-        code_units_to_be_read = bytes_to_be_read // 2
-        code_units_read = c_ulong()
-
-        rv = ReadConsoleW(self.handle, buffer, code_units_to_be_read,
-                          byref(code_units_read), None)
-        if GetLastError() == ERROR_OPERATION_ABORTED:
-            # wait for KeyboardInterrupt
-            time.sleep(0.1)
-        if not rv:
-            raise OSError('Windows error: %s' % GetLastError())
-
-        if buffer[0] == EOF:
-            return 0
-        return 2 * code_units_read.value
-
-
-class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
-
-    def writable(self):
-        return True
-
-    @staticmethod
-    def _get_error_message(errno):
-        if errno == ERROR_SUCCESS:
-            return 'ERROR_SUCCESS'
-        elif errno == ERROR_NOT_ENOUGH_MEMORY:
-            return 'ERROR_NOT_ENOUGH_MEMORY'
-        return 'Windows error %s' % errno
-
-    def write(self, b):
-        bytes_to_be_written = len(b)
-        buf = get_buffer(b)
-        code_units_to_be_written = min(bytes_to_be_written,
-                                       MAX_BYTES_WRITTEN) // 2
-        code_units_written = c_ulong()
-
-        WriteConsoleW(self.handle, buf, code_units_to_be_written,
-                      byref(code_units_written), None)
-        bytes_written = 2 * code_units_written.value
-
-        if bytes_written == 0 and bytes_to_be_written > 0:
-            raise OSError(self._get_error_message(GetLastError()))
-        return bytes_written
-
-
-class ConsoleStream(object):
-
-    def __init__(self, text_stream, byte_stream):
-        self._text_stream = text_stream
-        self.buffer = byte_stream
-
-    @property
-    def name(self):
-        return self.buffer.name
-
-    def write(self, x):
-        if isinstance(x, text_type):
-            return self._text_stream.write(x)
-        try:
-            self.flush()
-        except Exception:
-            pass
-        return self.buffer.write(x)
-
-    def writelines(self, lines):
-        for line in lines:
-            self.write(line)
-
-    def __getattr__(self, name):
-        return getattr(self._text_stream, name)
-
-    def isatty(self):
-        return self.buffer.isatty()
-
-    def __repr__(self):
-        return '<ConsoleStream name=%r encoding=%r>' % (
-            self.name,
-            self.encoding,
-        )
-
-
-def _get_text_stdin(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
-        'utf-16-le', 'strict', line_buffering=True)
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-def _get_text_stdout(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        _WindowsConsoleWriter(STDOUT_HANDLE),
-        'utf-16-le', 'strict', line_buffering=True)
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-def _get_text_stderr(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        _WindowsConsoleWriter(STDERR_HANDLE),
-        'utf-16-le', 'strict', line_buffering=True)
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-if PY2:
-    def _hash_py_argv():
-        return zlib.crc32('\x00'.join(sys.argv[1:]))
-
-    _initial_argv_hash = _hash_py_argv()
-
-    def _get_windows_argv():
-        argc = c_int(0)
-        argv_unicode = CommandLineToArgvW(GetCommandLineW(), byref(argc))
-        argv = [argv_unicode[i] for i in range(0, argc.value)]
-
-        if not hasattr(sys, 'frozen'):
-            argv = argv[1:]
-            while len(argv) > 0:
-                arg = argv[0]
-                if not arg.startswith('-') or arg == '-':
-                    break
-                argv = argv[1:]
-                if arg.startswith(('-c', '-m')):
-                    break
-
-        return argv[1:]
-
-
-_stream_factories = {
-    0: _get_text_stdin,
-    1: _get_text_stdout,
-    2: _get_text_stderr,
-}
-
-
-def _get_windows_console_stream(f, encoding, errors):
-    if get_buffer is not None and \
-       encoding in ('utf-16-le', None) \
-       and errors in ('strict', None) and \
-       hasattr(f, 'isatty') and f.isatty():
-        func = _stream_factories.get(f.fileno())
-        if func is not None:
-            if not PY2:
-                f = getattr(f, 'buffer')
-                if f is None:
-                    return None
-            else:
-                # If we are on Python 2 we need to set the stream that we
-                # deal with to binary mode as otherwise the exercise if a
-                # bit moot.  The same problems apply as for
-                # get_binary_stdin and friends from _compat.
-                msvcrt.setmode(f.fileno(), os.O_BINARY)
-            return func(f)