diff options
34 files changed, 1313 insertions, 1257 deletions
diff --git a/Doc/tools/extensions/pyspecific.py b/Doc/tools/extensions/pyspecific.py index d44b052..9b78184 100644 --- a/Doc/tools/extensions/pyspecific.py +++ b/Doc/tools/extensions/pyspecific.py @@ -34,7 +34,7 @@ import suspicious ISSUE_URI = 'https://bugs.python.org/issue%s' -SOURCE_URI = 'https://hg.python.org/cpython/file/3.5/%s' +SOURCE_URI = 'https://hg.python.org/cpython/file/default/%s' # monkey-patch reST parser to disable alphabetic and roman enumerated lists from docutils.parsers.rst.states import Body diff --git a/Doc/tutorial/interpreter.rst b/Doc/tutorial/interpreter.rst index d5789a6..db0be32 100644 --- a/Doc/tutorial/interpreter.rst +++ b/Doc/tutorial/interpreter.rst @@ -1,4 +1,4 @@ -.. _tut-using: +3.6.. _tut-using: **************************** Using the Python Interpreter @@ -10,13 +10,13 @@ Using the Python Interpreter Invoking the Interpreter ======================== -The Python interpreter is usually installed as :file:`/usr/local/bin/python3.5` +The Python interpreter is usually installed as :file:`/usr/local/bin/python3.6` on those machines where it is available; putting :file:`/usr/local/bin` in your Unix shell's search path makes it possible to start it by typing the command: .. code-block:: text - python3.5 + python3.6 to the shell. [#]_ Since the choice of the directory where the interpreter lives is an installation option, other places are possible; check with your local @@ -24,11 +24,11 @@ Python guru or system administrator. (E.g., :file:`/usr/local/python` is a popular alternative location.) On Windows machines, the Python installation is usually placed in -:file:`C:\\Python35`, though you can change this when you're running the +:file:`C:\\Python36`, though you can change this when you're running the installer. To add this directory to your path, you can type the following command into the command prompt in a DOS box:: - set path=%path%;C:\python35 + set path=%path%;C:\python36 Typing an end-of-file character (:kbd:`Control-D` on Unix, :kbd:`Control-Z` on Windows) at the primary prompt causes the interpreter to exit with a zero exit @@ -96,8 +96,8 @@ with the *secondary prompt*, by default three dots (``...``). The interpreter prints a welcome message stating its version number and a copyright notice before printing the first prompt:: - $ python3.5 - Python 3.5 (default, Sep 16 2015, 09:25:04) + $ python3.6 + Python 3.6 (default, Sep 16 2015, 09:25:04) [GCC 4.8.2] on linux Type "help", "copyright", "credits" or "license" for more information. >>> diff --git a/Doc/tutorial/stdlib.rst b/Doc/tutorial/stdlib.rst index 0954eba..f9ed46d 100644 --- a/Doc/tutorial/stdlib.rst +++ b/Doc/tutorial/stdlib.rst @@ -15,7 +15,7 @@ operating system:: >>> import os >>> os.getcwd() # Return the current working directory - 'C:\\Python35' + 'C:\\Python36' >>> os.chdir('/server/accesslogs') # Change current working directory >>> os.system('mkdir today') # Run the command mkdir in the system shell 0 diff --git a/Doc/tutorial/stdlib2.rst b/Doc/tutorial/stdlib2.rst index f7d2a0a..71194b0 100644 --- a/Doc/tutorial/stdlib2.rst +++ b/Doc/tutorial/stdlib2.rst @@ -277,7 +277,7 @@ applications include caching objects that are expensive to create:: Traceback (most recent call last): File "<stdin>", line 1, in <module> d['primary'] # entry was automatically removed - File "C:/python35/lib/weakref.py", line 46, in __getitem__ + File "C:/python36/lib/weakref.py", line 46, in __getitem__ o = self.data[key]() KeyError: 'primary' diff --git a/Doc/whatsnew/3.6.rst b/Doc/whatsnew/3.6.rst new file mode 100644 index 0000000..375d94e --- /dev/null +++ b/Doc/whatsnew/3.6.rst @@ -0,0 +1,166 @@ +**************************** + What's New In Python 3.6 +**************************** + +:Release: |release| +:Date: |today| + +.. Rules for maintenance: + + * Anyone can add text to this document. Do not spend very much time + on the wording of your changes, because your text will probably + get rewritten to some degree. + + * The maintainer will go through Misc/NEWS periodically and add + changes; it's therefore more important to add your changes to + Misc/NEWS than to this file. + + * This is not a complete list of every single change; completeness + is the purpose of Misc/NEWS. Some changes I consider too small + or esoteric to include. If such a change is added to the text, + I'll just remove it. (This is another reason you shouldn't spend + too much time on writing your addition.) + + * If you want to draw your new text to the attention of the + maintainer, add 'XXX' to the beginning of the paragraph or + section. + + * It's OK to just add a fragmentary note about a change. For + example: "XXX Describe the transmogrify() function added to the + socket module." The maintainer will research the change and + write the necessary text. + + * You can comment out your additions if you like, but it's not + necessary (especially when a final release is some months away). + + * Credit the author of a patch or bugfix. Just the name is + sufficient; the e-mail address isn't necessary. + + * It's helpful to add the bug/patch number as a comment: + + XXX Describe the transmogrify() function added to the socket + module. + (Contributed by P.Y. Developer in :issue:`12345`.) + + This saves the maintainer the effort of going through the Mercurial log + when researching a change. + +This article explains the new features in Python 3.6, compared to 3.5. + +For full details, see the :source:`Misc/NEWS` file. + +.. note:: + + Prerelease users should be aware that this document is currently in draft + form. It will be updated substantially as Python 3.6 moves towards release, + so it's worth checking back even after reading earlier versions. + + +Summary -- Release highlights +============================= + +.. This section singles out the most important changes in Python 3.6. + Brevity is key. + +* None yet. + +.. PEP-sized items next. + +.. _pep-4XX: + +.. PEP 4XX: Virtual Environments +.. ============================= + + +.. (Implemented by Foo Bar.) + +.. .. seealso:: + + :pep:`4XX` - Python Virtual Environments + PEP written by Carl Meyer + + +Other Language Changes +====================== + +* None yet. + + +New Modules +=========== + +* None yet. + + +Improved Modules +================ + +* None yet. + + +Optimizations +============= + +* None yet. + + +Build and C API Changes +======================= + +* None yet. + + +Deprecated +========== + +New Keywords +------------ + +``async`` and ``await`` are not recommended to be used as variable, class or +function names. Introduced by :pep:`492` in Python 3.5, they will become +proper keywords in Python 3.7. + + +Deprecated Python modules, functions and methods +------------------------------------------------ + +* None yet. + + +Deprecated functions and types of the C API +------------------------------------------- + +* None yet. + + +Deprecated features +------------------- + +* None yet. + + +Removed +======= + +API and Feature Removals +------------------------ + +* None yet. + + +Porting to Python 3.6 +===================== + +This section lists previously described changes and other bugfixes +that may require changes to your code. + +Changes in the Python API +------------------------- + +* None yet. + + +Changes in the C API +-------------------- + +* None yet. diff --git a/Doc/whatsnew/index.rst b/Doc/whatsnew/index.rst index edb5502..7c92524 100644 --- a/Doc/whatsnew/index.rst +++ b/Doc/whatsnew/index.rst @@ -11,6 +11,7 @@ anyone wishing to stay up-to-date after a new release. .. toctree:: :maxdepth: 2 + 3.6.rst 3.5.rst 3.4.rst 3.3.rst diff --git a/Include/patchlevel.h b/Include/patchlevel.h index f1773f0..246eba8 100644 --- a/Include/patchlevel.h +++ b/Include/patchlevel.h @@ -17,13 +17,13 @@ /* Version parsed out into numeric values */ /*--start constants--*/ #define PY_MAJOR_VERSION 3 -#define PY_MINOR_VERSION 5 +#define PY_MINOR_VERSION 6 #define PY_MICRO_VERSION 0 -#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_BETA -#define PY_RELEASE_SERIAL 2 +#define PY_RELEASE_LEVEL PY_RELEASE_LEVEL_ALPHA +#define PY_RELEASE_SERIAL 0 /* Version as a string */ -#define PY_VERSION "3.5.0b2+" +#define PY_VERSION "3.6.0a0" /*--end constants--*/ /* Version as a single 4-byte hex number, e.g. 0x010502B2 == 1.5.2b2. diff --git a/Lib/pydoc_data/topics.py b/Lib/pydoc_data/topics.py index cc0c6ab..38857d2 100644 --- a/Lib/pydoc_data/topics.py +++ b/Lib/pydoc_data/topics.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Autogenerated by Sphinx on Sat May 30 16:57:51 2015 +# Autogenerated by Sphinx on Sat May 23 17:38:41 2015 topics = {'assert': u'\nThe "assert" statement\n**********************\n\nAssert statements are a convenient way to insert debugging assertions\ninto a program:\n\n assert_stmt ::= "assert" expression ["," expression]\n\nThe simple form, "assert expression", is equivalent to\n\n if __debug__:\n if not expression: raise AssertionError\n\nThe extended form, "assert expression1, expression2", is equivalent to\n\n if __debug__:\n if not expression1: raise AssertionError(expression2)\n\nThese equivalences assume that "__debug__" and "AssertionError" refer\nto the built-in variables with those names. In the current\nimplementation, the built-in variable "__debug__" is "True" under\nnormal circumstances, "False" when optimization is requested (command\nline option -O). The current code generator emits no code for an\nassert statement when optimization is requested at compile time. Note\nthat it is unnecessary to include the source code for the expression\nthat failed in the error message; it will be displayed as part of the\nstack trace.\n\nAssignments to "__debug__" are illegal. The value for the built-in\nvariable is determined when the interpreter starts.\n', 'assignment': u'\nAssignment statements\n*********************\n\nAssignment statements are used to (re)bind names to values and to\nmodify attributes or items of mutable objects:\n\n assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)\n target_list ::= target ("," target)* [","]\n target ::= identifier\n | "(" target_list ")"\n | "[" target_list "]"\n | attributeref\n | subscription\n | slicing\n | "*" target\n\n(See section *Primaries* for the syntax definitions for\n*attributeref*, *subscription*, and *slicing*.)\n\nAn assignment statement evaluates the expression list (remember that\nthis can be a single expression or a comma-separated list, the latter\nyielding a tuple) and assigns the single resulting object to each of\nthe target lists, from left to right.\n\nAssignment is defined recursively depending on the form of the target\n(list). When a target is part of a mutable object (an attribute\nreference, subscription or slicing), the mutable object must\nultimately perform the assignment and decide about its validity, and\nmay raise an exception if the assignment is unacceptable. The rules\nobserved by various types and the exceptions raised are given with the\ndefinition of the object types (see section *The standard type\nhierarchy*).\n\nAssignment of an object to a target list, optionally enclosed in\nparentheses or square brackets, is recursively defined as follows.\n\n* If the target list is a single target: The object is assigned to\n that target.\n\n* If the target list is a comma-separated list of targets: The\n object must be an iterable with the same number of items as there\n are targets in the target list, and the items are assigned, from\n left to right, to the corresponding targets.\n\n * If the target list contains one target prefixed with an\n asterisk, called a "starred" target: The object must be a sequence\n with at least as many items as there are targets in the target\n list, minus one. The first items of the sequence are assigned,\n from left to right, to the targets before the starred target. The\n final items of the sequence are assigned to the targets after the\n starred target. A list of the remaining items in the sequence is\n then assigned to the starred target (the list can be empty).\n\n * Else: The object must be a sequence with the same number of\n items as there are targets in the target list, and the items are\n assigned, from left to right, to the corresponding targets.\n\nAssignment of an object to a single target is recursively defined as\nfollows.\n\n* If the target is an identifier (name):\n\n * If the name does not occur in a "global" or "nonlocal" statement\n in the current code block: the name is bound to the object in the\n current local namespace.\n\n * Otherwise: the name is bound to the object in the global\n namespace or the outer namespace determined by "nonlocal",\n respectively.\n\n The name is rebound if it was already bound. This may cause the\n reference count for the object previously bound to the name to reach\n zero, causing the object to be deallocated and its destructor (if it\n has one) to be called.\n\n* If the target is a target list enclosed in parentheses or in\n square brackets: The object must be an iterable with the same number\n of items as there are targets in the target list, and its items are\n assigned, from left to right, to the corresponding targets.\n\n* If the target is an attribute reference: The primary expression in\n the reference is evaluated. It should yield an object with\n assignable attributes; if this is not the case, "TypeError" is\n raised. That object is then asked to assign the assigned object to\n the given attribute; if it cannot perform the assignment, it raises\n an exception (usually but not necessarily "AttributeError").\n\n Note: If the object is a class instance and the attribute reference\n occurs on both sides of the assignment operator, the RHS expression,\n "a.x" can access either an instance attribute or (if no instance\n attribute exists) a class attribute. The LHS target "a.x" is always\n set as an instance attribute, creating it if necessary. Thus, the\n two occurrences of "a.x" do not necessarily refer to the same\n attribute: if the RHS expression refers to a class attribute, the\n LHS creates a new instance attribute as the target of the\n assignment:\n\n class Cls:\n x = 3 # class variable\n inst = Cls()\n inst.x = inst.x + 1 # writes inst.x as 4 leaving Cls.x as 3\n\n This description does not necessarily apply to descriptor\n attributes, such as properties created with "property()".\n\n* If the target is a subscription: The primary expression in the\n reference is evaluated. It should yield either a mutable sequence\n object (such as a list) or a mapping object (such as a dictionary).\n Next, the subscript expression is evaluated.\n\n If the primary is a mutable sequence object (such as a list), the\n subscript must yield an integer. If it is negative, the sequence\'s\n length is added to it. The resulting value must be a nonnegative\n integer less than the sequence\'s length, and the sequence is asked\n to assign the assigned object to its item with that index. If the\n index is out of range, "IndexError" is raised (assignment to a\n subscripted sequence cannot add new items to a list).\n\n If the primary is a mapping object (such as a dictionary), the\n subscript must have a type compatible with the mapping\'s key type,\n and the mapping is then asked to create a key/datum pair which maps\n the subscript to the assigned object. This can either replace an\n existing key/value pair with the same key value, or insert a new\n key/value pair (if no key with the same value existed).\n\n For user-defined objects, the "__setitem__()" method is called with\n appropriate arguments.\n\n* If the target is a slicing: The primary expression in the\n reference is evaluated. It should yield a mutable sequence object\n (such as a list). The assigned object should be a sequence object\n of the same type. Next, the lower and upper bound expressions are\n evaluated, insofar they are present; defaults are zero and the\n sequence\'s length. The bounds should evaluate to integers. If\n either bound is negative, the sequence\'s length is added to it. The\n resulting bounds are clipped to lie between zero and the sequence\'s\n length, inclusive. Finally, the sequence object is asked to replace\n the slice with the items of the assigned sequence. The length of\n the slice may be different from the length of the assigned sequence,\n thus changing the length of the target sequence, if the target\n sequence allows it.\n\n**CPython implementation detail:** In the current implementation, the\nsyntax for targets is taken to be the same as for expressions, and\ninvalid syntax is rejected during the code generation phase, causing\nless detailed error messages.\n\nAlthough the definition of assignment implies that overlaps between\nthe left-hand side and the right-hand side are \'simultanenous\' (for\nexample "a, b = b, a" swaps two variables), overlaps *within* the\ncollection of assigned-to variables occur left-to-right, sometimes\nresulting in confusion. For instance, the following program prints\n"[0, 2]":\n\n x = [0, 1]\n i = 0\n i, x[i] = 1, 2 # i is updated, then x[i] is updated\n print(x)\n\nSee also: **PEP 3132** - Extended Iterable Unpacking\n\n The specification for the "*target" feature.\n\n\nAugmented assignment statements\n===============================\n\nAugmented assignment is the combination, in a single statement, of a\nbinary operation and an assignment statement:\n\n augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)\n augtarget ::= identifier | attributeref | subscription | slicing\n augop ::= "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="\n | ">>=" | "<<=" | "&=" | "^=" | "|="\n\n(See section *Primaries* for the syntax definitions of the last three\nsymbols.)\n\nAn augmented assignment evaluates the target (which, unlike normal\nassignment statements, cannot be an unpacking) and the expression\nlist, performs the binary operation specific to the type of assignment\non the two operands, and assigns the result to the original target.\nThe target is only evaluated once.\n\nAn augmented assignment expression like "x += 1" can be rewritten as\n"x = x + 1" to achieve a similar, but not exactly equal effect. In the\naugmented version, "x" is only evaluated once. Also, when possible,\nthe actual operation is performed *in-place*, meaning that rather than\ncreating a new object and assigning that to the target, the old object\nis modified instead.\n\nUnlike normal assignments, augmented assignments evaluate the left-\nhand side *before* evaluating the right-hand side. For example, "a[i]\n+= f(x)" first looks-up "a[i]", then it evaluates "f(x)" and performs\nthe addition, and lastly, it writes the result back to "a[i]".\n\nWith the exception of assigning to tuples and multiple targets in a\nsingle statement, the assignment done by augmented assignment\nstatements is handled the same way as normal assignments. Similarly,\nwith the exception of the possible *in-place* behavior, the binary\noperation performed by augmented assignment is the same as the normal\nbinary operations.\n\nFor targets which are attribute references, the same *caveat about\nclass and instance attributes* applies as for regular assignments.\n', 'atom-identifiers': u'\nIdentifiers (Names)\n*******************\n\nAn identifier occurring as an atom is a name. See section\n*Identifiers and keywords* for lexical definition and section *Naming\nand binding* for documentation of naming and binding.\n\nWhen the name is bound to an object, evaluation of the atom yields\nthat object. When a name is not bound, an attempt to evaluate it\nraises a "NameError" exception.\n\n**Private name mangling:** When an identifier that textually occurs in\na class definition begins with two or more underscore characters and\ndoes not end in two or more underscores, it is considered a *private\nname* of that class. Private names are transformed to a longer form\nbefore code is generated for them. The transformation inserts the\nclass name, with leading underscores removed and a single underscore\ninserted, in front of the name. For example, the identifier "__spam"\noccurring in a class named "Ham" will be transformed to "_Ham__spam".\nThis transformation is independent of the syntactical context in which\nthe identifier is used. If the transformed name is extremely long\n(longer than 255 characters), implementation defined truncation may\nhappen. If the class name consists only of underscores, no\ntransformation is done.\n', diff --git a/Lib/sre_compile.py b/Lib/sre_compile.py index 502b061..4edb03f 100644 --- a/Lib/sre_compile.py +++ b/Lib/sre_compile.py @@ -409,57 +409,39 @@ def _generate_overlap_table(prefix): table[i] = idx + 1 return table -def _compile_info(code, pattern, flags): - # internal: compile an info block. in the current version, - # this contains min/max pattern width, and an optional literal - # prefix or a character map - lo, hi = pattern.getwidth() - if hi > MAXCODE: - hi = MAXCODE - if lo == 0: - code.extend([INFO, 4, 0, lo, hi]) - return - # look for a literal prefix +def _get_literal_prefix(pattern): + # look for literal prefix prefix = [] prefixappend = prefix.append - prefix_skip = 0 + prefix_skip = None + got_all = True + for op, av in pattern.data: + if op is LITERAL: + prefixappend(av) + elif op is SUBPATTERN: + prefix1, prefix_skip1, got_all = _get_literal_prefix(av[1]) + if prefix_skip is None: + if av[0] is not None: + prefix_skip = len(prefix) + elif prefix_skip1 is not None: + prefix_skip = len(prefix) + prefix_skip1 + prefix.extend(prefix1) + if not got_all: + break + else: + got_all = False + break + return prefix, prefix_skip, got_all + +def _get_charset_prefix(pattern): charset = [] # not used charsetappend = charset.append - if not (flags & SRE_FLAG_IGNORECASE): - # look for literal prefix - for op, av in pattern.data: + if pattern.data: + op, av = pattern.data[0] + if op is SUBPATTERN and av[1]: + op, av = av[1][0] if op is LITERAL: - if len(prefix) == prefix_skip: - prefix_skip = prefix_skip + 1 - prefixappend(av) - elif op is SUBPATTERN and len(av[1]) == 1: - op, av = av[1][0] - if op is LITERAL: - prefixappend(av) - else: - break - else: - break - # if no prefix, look for charset prefix - if not prefix and pattern.data: - op, av = pattern.data[0] - if op is SUBPATTERN and av[1]: - op, av = av[1][0] - if op is LITERAL: - charsetappend((op, av)) - elif op is BRANCH: - c = [] - cappend = c.append - for p in av[1]: - if not p: - break - op, av = p[0] - if op is LITERAL: - cappend((op, av)) - else: - break - else: - charset = c + charsetappend((op, av)) elif op is BRANCH: c = [] cappend = c.append @@ -473,8 +455,43 @@ def _compile_info(code, pattern, flags): break else: charset = c - elif op is IN: - charset = av + elif op is BRANCH: + c = [] + cappend = c.append + for p in av[1]: + if not p: + break + op, av = p[0] + if op is LITERAL: + cappend((op, av)) + else: + break + else: + charset = c + elif op is IN: + charset = av + return charset + +def _compile_info(code, pattern, flags): + # internal: compile an info block. in the current version, + # this contains min/max pattern width, and an optional literal + # prefix or a character map + lo, hi = pattern.getwidth() + if hi > MAXCODE: + hi = MAXCODE + if lo == 0: + code.extend([INFO, 4, 0, lo, hi]) + return + # look for a literal prefix + prefix = [] + prefix_skip = 0 + charset = [] # not used + if not (flags & SRE_FLAG_IGNORECASE): + # look for literal prefix + prefix, prefix_skip, got_all = _get_literal_prefix(pattern) + # if no prefix, look for charset prefix + if not prefix: + charset = _get_charset_prefix(pattern) ## if prefix: ## print("*** PREFIX", prefix, prefix_skip) ## if charset: @@ -487,7 +504,7 @@ def _compile_info(code, pattern, flags): mask = 0 if prefix: mask = SRE_INFO_PREFIX - if len(prefix) == prefix_skip == len(pattern.data): + if prefix_skip is None and got_all: mask = mask | SRE_INFO_LITERAL elif charset: mask = mask | SRE_INFO_CHARSET @@ -502,6 +519,8 @@ def _compile_info(code, pattern, flags): # add literal prefix if prefix: emit(len(prefix)) # length + if prefix_skip is None: + prefix_skip = len(prefix) emit(prefix_skip) # skip code.extend(prefix) # generate overlap table diff --git a/Lib/string.py b/Lib/string.py index f3365c6..e7b692d 100644 --- a/Lib/string.py +++ b/Lib/string.py @@ -112,10 +112,7 @@ class Template(metaclass=_TemplateMetaclass): # Check the most common path first. named = mo.group('named') or mo.group('braced') if named is not None: - val = mapping[named] - # We use this idiom instead of str() because the latter will - # fail if val is a Unicode containing non-ASCII characters. - return '%s' % (val,) + return str(mapping[named]) if mo.group('escaped') is not None: return self.delimiter if mo.group('invalid') is not None: @@ -142,9 +139,7 @@ class Template(metaclass=_TemplateMetaclass): named = mo.group('named') or mo.group('braced') if named is not None: try: - # We use this idiom instead of str() because the latter - # will fail if val is a Unicode containing non-ASCII - return '%s' % (mapping[named],) + return str(mapping[named]) except KeyError: return mo.group() if mo.group('escaped') is not None: diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index fbaf712..07420c6 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -1992,6 +1992,14 @@ class OrderedDictTests: od = OrderedDict(**d) self.assertGreater(sys.getsizeof(od), sys.getsizeof(d)) + def test_views(self): + OrderedDict = self.module.OrderedDict + # See http://bugs.python.org/issue24286 + s = 'the quick brown fox jumped over a lazy dog yesterday before dawn'.split() + od = OrderedDict.fromkeys(s) + self.assertEqual(od.keys(), dict(od).keys()) + self.assertEqual(od.items(), dict(od).items()) + def test_override_update(self): OrderedDict = self.module.OrderedDict # Verify that subclasses can override update() without breaking __init__() diff --git a/Lib/test/test_dictviews.py b/Lib/test/test_dictviews.py index 8d33801..fcb6814 100644 --- a/Lib/test/test_dictviews.py +++ b/Lib/test/test_dictviews.py @@ -1,3 +1,4 @@ +import collections import unittest class DictSetTest(unittest.TestCase): @@ -197,6 +198,27 @@ class DictSetTest(unittest.TestCase): d[42] = d.values() self.assertRaises(RecursionError, repr, d) + def test_abc_registry(self): + d = dict(a=1) + + self.assertIsInstance(d.keys(), collections.KeysView) + self.assertIsInstance(d.keys(), collections.MappingView) + self.assertIsInstance(d.keys(), collections.Set) + self.assertIsInstance(d.keys(), collections.Sized) + self.assertIsInstance(d.keys(), collections.Iterable) + self.assertIsInstance(d.keys(), collections.Container) + + self.assertIsInstance(d.values(), collections.ValuesView) + self.assertIsInstance(d.values(), collections.MappingView) + self.assertIsInstance(d.values(), collections.Sized) + + self.assertIsInstance(d.items(), collections.ItemsView) + self.assertIsInstance(d.items(), collections.MappingView) + self.assertIsInstance(d.items(), collections.Set) + self.assertIsInstance(d.items(), collections.Sized) + self.assertIsInstance(d.items(), collections.Iterable) + self.assertIsInstance(d.items(), collections.Container) + if __name__ == "__main__": unittest.main() diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py index 6581e35..fd8269d 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -213,15 +213,10 @@ class FileTests(unittest.TestCase): # Test attributes on return values from os.*stat* family. class StatAttributeTests(unittest.TestCase): def setUp(self): - os.mkdir(support.TESTFN) - self.fname = os.path.join(support.TESTFN, "f1") - f = open(self.fname, 'wb') - f.write(b"ABC") - f.close() - - def tearDown(self): - os.unlink(self.fname) - os.rmdir(support.TESTFN) + self.fname = support.TESTFN + self.addCleanup(support.unlink, self.fname) + with open(self.fname, 'wb') as fp: + fp.write(b"ABC") @unittest.skipUnless(hasattr(os, 'stat'), 'test needs os.stat()') def check_stat_attributes(self, fname): @@ -413,7 +408,11 @@ class StatAttributeTests(unittest.TestCase): 0) # test directory st_file_attributes (FILE_ATTRIBUTE_DIRECTORY set) - result = os.stat(support.TESTFN) + dirname = support.TESTFN + "dir" + os.mkdir(dirname) + self.addCleanup(os.rmdir, dirname) + + result = os.stat(dirname) self.check_file_attributes(result) self.assertEqual( result.st_file_attributes & stat.FILE_ATTRIBUTE_DIRECTORY, diff --git a/Lib/test/test_symbol.py b/Lib/test/test_symbol.py new file mode 100644 index 0000000..4475bbc --- /dev/null +++ b/Lib/test/test_symbol.py @@ -0,0 +1,45 @@ +import unittest +from test import support +import filecmp +import os +import sys +import subprocess + + +SYMBOL_FILE = support.findfile('symbol.py') +GRAMMAR_FILE = os.path.join(os.path.dirname(__file__), + '..', '..', 'Include', 'graminit.h') +TEST_PY_FILE = 'symbol_test.py' + + +class TestSymbolGeneration(unittest.TestCase): + + def _copy_file_without_generated_symbols(self, source_file, dest_file): + with open(source_file, 'rb') as fp: + lines = fp.readlines() + nl = lines[0][len(lines[0].rstrip()):] + with open(dest_file, 'wb') as fp: + fp.writelines(lines[:lines.index(b"#--start constants--" + nl) + 1]) + fp.writelines(lines[lines.index(b"#--end constants--" + nl):]) + + def _generate_symbols(self, grammar_file, target_symbol_py_file): + proc = subprocess.Popen([sys.executable, + SYMBOL_FILE, + grammar_file, + target_symbol_py_file], stderr=subprocess.PIPE) + stderr = proc.communicate()[1] + return proc.returncode, stderr + + @unittest.skipIf(not os.path.exists(GRAMMAR_FILE), + 'test only works from source build directory') + def test_real_grammar_and_symbol_file(self): + self._copy_file_without_generated_symbols(SYMBOL_FILE, TEST_PY_FILE) + self.addCleanup(support.unlink, TEST_PY_FILE) + self.assertFalse(filecmp.cmp(SYMBOL_FILE, TEST_PY_FILE)) + self.assertEqual((0, b''), self._generate_symbols(GRAMMAR_FILE, + TEST_PY_FILE)) + self.assertTrue(filecmp.cmp(SYMBOL_FILE, TEST_PY_FILE)) + + +if __name__ == "__main__": + unittest.main() diff --git a/Lib/test/test_typing.py b/Lib/test/test_typing.py index c37e113..2bb21ed 100644 --- a/Lib/test/test_typing.py +++ b/Lib/test/test_typing.py @@ -41,11 +41,9 @@ class ManagingFounder(Manager, Founder): class AnyTests(TestCase): - def test_any_instance(self): - self.assertIsInstance(Employee(), Any) - self.assertIsInstance(42, Any) - self.assertIsInstance(None, Any) - self.assertIsInstance(object(), Any) + def test_any_instance_type_error(self): + with self.assertRaises(TypeError): + isinstance(42, Any) def test_any_subclass(self): self.assertTrue(issubclass(Employee, Any)) @@ -109,9 +107,6 @@ class TypeVarTests(TestCase): def test_basic_plain(self): T = TypeVar('T') - # Nothing is an instance if T. - with self.assertRaises(TypeError): - isinstance('', T) # Every class is a subclass of T. assert issubclass(int, T) assert issubclass(str, T) @@ -119,12 +114,16 @@ class TypeVarTests(TestCase): assert T == T # T is a subclass of itself. assert issubclass(T, T) + # T is an instance of TypeVar + assert isinstance(T, TypeVar) + + def test_typevar_instance_type_error(self): + T = TypeVar('T') + with self.assertRaises(TypeError): + isinstance(42, T) def test_basic_constrained(self): A = TypeVar('A', str, bytes) - # Nothing is an instance of A. - with self.assertRaises(TypeError): - isinstance('', A) # Only str and bytes are subclasses of A. assert issubclass(str, A) assert issubclass(bytes, A) @@ -213,8 +212,6 @@ class UnionTests(TestCase): def test_basics(self): u = Union[int, float] self.assertNotEqual(u, Union) - self.assertIsInstance(42, u) - self.assertIsInstance(3.14, u) self.assertTrue(issubclass(int, u)) self.assertTrue(issubclass(float, u)) @@ -247,7 +244,6 @@ class UnionTests(TestCase): def test_subclass(self): u = Union[int, Employee] - self.assertIsInstance(Manager(), u) self.assertTrue(issubclass(Manager, u)) def test_self_subclass(self): @@ -256,7 +252,6 @@ class UnionTests(TestCase): def test_multiple_inheritance(self): u = Union[int, Employee] - self.assertIsInstance(ManagingFounder(), u) self.assertTrue(issubclass(ManagingFounder, u)) def test_single_class_disappears(self): @@ -309,9 +304,6 @@ class UnionTests(TestCase): o = Optional[int] u = Union[int, None] self.assertEqual(o, u) - self.assertIsInstance(42, o) - self.assertIsInstance(None, o) - self.assertNotIsInstance(3.14, o) def test_empty(self): with self.assertRaises(TypeError): @@ -321,11 +313,9 @@ class UnionTests(TestCase): assert issubclass(Union[int, str], Union) assert not issubclass(int, Union) - def test_isinstance_union(self): - # Nothing is an instance of bare Union. - assert not isinstance(42, Union) - assert not isinstance(int, Union) - assert not isinstance(Union[int, str], Union) + def test_union_instance_type_error(self): + with self.assertRaises(TypeError): + isinstance(42, Union[int, str]) class TypeVarUnionTests(TestCase): @@ -352,22 +342,11 @@ class TypeVarUnionTests(TestCase): TU = TypeVar('TU', Union[int, float], None) assert issubclass(int, TU) assert issubclass(float, TU) - with self.assertRaises(TypeError): - isinstance(42, TU) - with self.assertRaises(TypeError): - isinstance('', TU) class TupleTests(TestCase): def test_basics(self): - self.assertIsInstance((42, 3.14, ''), Tuple) - self.assertIsInstance((42, 3.14, ''), Tuple[int, float, str]) - self.assertIsInstance((42,), Tuple[int]) - self.assertNotIsInstance((3.14,), Tuple[int]) - self.assertNotIsInstance((42, 3.14), Tuple[int, float, str]) - self.assertNotIsInstance((42, 3.14, 100), Tuple[int, float, str]) - self.assertNotIsInstance((42, 3.14, 100), Tuple[int, float]) self.assertTrue(issubclass(Tuple[int, str], Tuple)) self.assertTrue(issubclass(Tuple[int, str], Tuple[int, str])) self.assertFalse(issubclass(int, Tuple)) @@ -382,14 +361,11 @@ class TupleTests(TestCase): pass self.assertTrue(issubclass(MyTuple, Tuple)) - def test_tuple_ellipsis(self): - t = Tuple[int, ...] - assert isinstance((), t) - assert isinstance((1,), t) - assert isinstance((1, 2), t) - assert isinstance((1, 2, 3), t) - assert not isinstance((3.14,), t) - assert not isinstance((1, 2, 3.14,), t) + def test_tuple_instance_type_error(self): + with self.assertRaises(TypeError): + isinstance((0, 0), Tuple[int, int]) + with self.assertRaises(TypeError): + isinstance((0, 0), Tuple) def test_tuple_ellipsis_subclass(self): @@ -419,18 +395,6 @@ class TupleTests(TestCase): class CallableTests(TestCase): - def test_basics(self): - c = Callable[[int, float], str] - - def flub(a: int, b: float) -> str: - return str(a * b) - - def flob(a: int, b: int) -> str: - return str(a * b) - - self.assertIsInstance(flub, c) - self.assertNotIsInstance(flob, c) - def test_self_subclass(self): self.assertTrue(issubclass(Callable[[int], int], Callable)) self.assertFalse(issubclass(Callable, Callable[[int], int])) @@ -453,91 +417,6 @@ class CallableTests(TestCase): self.assertNotEqual(Callable[[int], int], Callable[[], int]) self.assertNotEqual(Callable[[int], int], Callable) - def test_with_none(self): - c = Callable[[None], None] - - def flub(self: None) -> None: - pass - - def flab(self: Any) -> None: - pass - - def flob(self: None) -> Any: - pass - - self.assertIsInstance(flub, c) - self.assertIsInstance(flab, c) - self.assertNotIsInstance(flob, c) # Test contravariance. - - def test_with_subclasses(self): - c = Callable[[Employee, Manager], Employee] - - def flub(a: Employee, b: Employee) -> Manager: - return Manager() - - def flob(a: Manager, b: Manager) -> Employee: - return Employee() - - self.assertIsInstance(flub, c) - self.assertNotIsInstance(flob, c) - - def test_with_default_args(self): - c = Callable[[int], int] - - def flub(a: int, b: float = 3.14) -> int: - return a - - def flab(a: int, *, b: float = 3.14) -> int: - return a - - def flob(a: int = 42) -> int: - return a - - self.assertIsInstance(flub, c) - self.assertIsInstance(flab, c) - self.assertIsInstance(flob, c) - - def test_with_varargs(self): - c = Callable[[int], int] - - def flub(*args) -> int: - return 42 - - def flab(*args: int) -> int: - return 42 - - def flob(*args: float) -> int: - return 42 - - self.assertIsInstance(flub, c) - self.assertIsInstance(flab, c) - self.assertNotIsInstance(flob, c) - - def test_with_method(self): - - class C: - - def imethod(self, arg: int) -> int: - self.last_arg = arg - return arg + 1 - - @classmethod - def cmethod(cls, arg: int) -> int: - cls.last_cls_arg = arg - return arg + 1 - - @staticmethod - def smethod(arg: int) -> int: - return arg + 1 - - ct = Callable[[int], int] - self.assertIsInstance(C().imethod, ct) - self.assertIsInstance(C().cmethod, ct) - self.assertIsInstance(C.cmethod, ct) - self.assertIsInstance(C().smethod, ct) - self.assertIsInstance(C.smethod, ct) - self.assertIsInstance(C.imethod, Callable[[Any, int], int]) - def test_cannot_subclass(self): with self.assertRaises(TypeError): @@ -556,21 +435,21 @@ class CallableTests(TestCase): with self.assertRaises(TypeError): c() - def test_varargs(self): - ct = Callable[..., int] - - def foo(a, b) -> int: - return 42 + def test_callable_instance_works(self): + f = lambda: None + assert isinstance(f, Callable) + assert not isinstance(None, Callable) - def bar(a=42) -> int: - return a - - def baz(*, x, y, z) -> int: - return 100 - - self.assertIsInstance(foo, ct) - self.assertIsInstance(bar, ct) - self.assertIsInstance(baz, ct) + def test_callable_instance_type_error(self): + f = lambda: None + with self.assertRaises(TypeError): + assert isinstance(f, Callable[[], None]) + with self.assertRaises(TypeError): + assert isinstance(f, Callable[[], Any]) + with self.assertRaises(TypeError): + assert not isinstance(None, Callable[[], None]) + with self.assertRaises(TypeError): + assert not isinstance(None, Callable[[], Any]) def test_repr(self): ct0 = Callable[[], bool] @@ -659,6 +538,10 @@ class ProtocolTests(TestCase): assert issubclass(list, typing.Reversible) assert not issubclass(int, typing.Reversible) + def test_protocol_instance_type_error(self): + with self.assertRaises(TypeError): + isinstance([], typing.Reversible) + class GenericTests(TestCase): @@ -824,11 +707,11 @@ class VarianceTests(TestCase): typing.Sequence[Manager]) def test_covariance_mapping(self): - # Ditto for Mapping (a generic class with two parameters). + # Ditto for Mapping (covariant in the value, invariant in the key). assert issubclass(typing.Mapping[Employee, Manager], typing.Mapping[Employee, Employee]) - assert issubclass(typing.Mapping[Manager, Employee], - typing.Mapping[Employee, Employee]) + assert not issubclass(typing.Mapping[Manager, Employee], + typing.Mapping[Employee, Employee]) assert not issubclass(typing.Mapping[Employee, Manager], typing.Mapping[Manager, Manager]) assert not issubclass(typing.Mapping[Manager, Employee], @@ -889,6 +772,11 @@ class ForwardRefTests(TestCase): right_hints = get_type_hints(t.add_right, globals(), locals()) assert right_hints['node'] == Optional[Node[T]] + def test_forwardref_instance_type_error(self): + fr = typing._ForwardRef('int') + with self.assertRaises(TypeError): + isinstance(42, fr) + def test_union_forward(self): def foo(a: Union['T']): @@ -1069,50 +957,17 @@ class CollectionsAbcTests(TestCase): def test_list(self): assert issubclass(list, typing.List) - assert isinstance([], typing.List) - assert not isinstance((), typing.List) - t = typing.List[int] - assert isinstance([], t) - assert isinstance([42], t) - assert not isinstance([''], t) def test_set(self): assert issubclass(set, typing.Set) assert not issubclass(frozenset, typing.Set) - assert isinstance(set(), typing.Set) - assert not isinstance({}, typing.Set) - t = typing.Set[int] - assert isinstance(set(), t) - assert isinstance({42}, t) - assert not isinstance({''}, t) def test_frozenset(self): assert issubclass(frozenset, typing.FrozenSet) assert not issubclass(set, typing.FrozenSet) - assert isinstance(frozenset(), typing.FrozenSet) - assert not isinstance({}, typing.FrozenSet) - t = typing.FrozenSet[int] - assert isinstance(frozenset(), t) - assert isinstance(frozenset({42}), t) - assert not isinstance(frozenset({''}), t) - assert not isinstance({42}, t) - - def test_mapping_views(self): - # TODO: These tests are kind of lame. - assert isinstance({}.keys(), typing.KeysView) - assert isinstance({}.items(), typing.ItemsView) - assert isinstance({}.values(), typing.ValuesView) def test_dict(self): assert issubclass(dict, typing.Dict) - assert isinstance({}, typing.Dict) - assert not isinstance([], typing.Dict) - t = typing.Dict[int, str] - assert isinstance({}, t) - assert isinstance({42: ''}, t) - assert not isinstance({42: 42}, t) - assert not isinstance({'': 42}, t) - assert not isinstance({'': ''}, t) def test_no_list_instantiation(self): with self.assertRaises(TypeError): @@ -1191,8 +1046,6 @@ class CollectionsAbcTests(TestCase): yield 42 g = foo() assert issubclass(type(g), typing.Generator) - assert isinstance(g, typing.Generator) - assert not isinstance(foo, typing.Generator) assert issubclass(typing.Generator[Manager, Employee, Manager], typing.Generator[Employee, Manager, Employee]) assert not issubclass(typing.Generator[Manager, Manager, Manager], @@ -1228,12 +1081,6 @@ class CollectionsAbcTests(TestCase): assert len(MMB[str, str]()) == 0 assert len(MMB[KT, VT]()) == 0 - def test_recursive_dict(self): - D = typing.Dict[int, 'D'] # Uses a _ForwardRef - assert isinstance({}, D) # Easy - assert isinstance({0: {}}, D) # Touches _ForwardRef - assert isinstance({0: {0: {}}}, D) # Etc... - class NamedTupleTests(TestCase): @@ -1294,8 +1141,6 @@ class RETests(TestCase): def test_basics(self): pat = re.compile('[a-z]+', re.I) assert issubclass(pat.__class__, Pattern) - assert isinstance(pat, Pattern[str]) - assert not isinstance(pat, Pattern[bytes]) assert issubclass(type(pat), Pattern) assert issubclass(type(pat), Pattern[str]) @@ -1307,12 +1152,10 @@ class RETests(TestCase): assert issubclass(type(mat), Match[str]) p = Pattern[Union[str, bytes]] - assert isinstance(pat, p) assert issubclass(Pattern[str], Pattern) assert issubclass(Pattern[str], p) m = Match[Union[bytes, str]] - assert isinstance(mat, m) assert issubclass(Match[bytes], Match) assert issubclass(Match[bytes], m) @@ -1327,6 +1170,12 @@ class RETests(TestCase): with self.assertRaises(TypeError): # Too complicated? m[str] + with self.assertRaises(TypeError): + # We don't support isinstance(). + isinstance(42, Pattern) + with self.assertRaises(TypeError): + # We don't support isinstance(). + isinstance(42, Pattern[str]) def test_repr(self): assert repr(Pattern) == 'Pattern[~AnyStr]' diff --git a/Lib/typing.py b/Lib/typing.py index 38e07ad..bc6fcdd 100644 --- a/Lib/typing.py +++ b/Lib/typing.py @@ -176,6 +176,9 @@ class _ForwardRef(TypingMeta): self.__forward_evaluated__ = True return self.__forward_value__ + def __instancecheck__(self, obj): + raise TypeError("Forward references cannot be used with isinstance().") + def __subclasscheck__(self, cls): if not self.__forward_evaluated__: globalns = self.__forward_frame__.f_globals @@ -186,16 +189,6 @@ class _ForwardRef(TypingMeta): return False # Too early. return issubclass(cls, self.__forward_value__) - def __instancecheck__(self, obj): - if not self.__forward_evaluated__: - globalns = self.__forward_frame__.f_globals - localns = self.__forward_frame__.f_locals - try: - self._eval_type(globalns, localns) - except NameError: - return False # Too early. - return isinstance(obj, self.__forward_value__) - def __repr__(self): return '_ForwardRef(%r)' % (self.__forward_arg__,) @@ -259,8 +252,7 @@ class _TypeAlias: self.impl_type, self.type_checker) def __instancecheck__(self, obj): - return (isinstance(obj, self.impl_type) and - isinstance(self.type_checker(obj), self.type_var)) + raise TypeError("Type aliases cannot be used with isinstance().") def __subclasscheck__(self, cls): if cls is Any: @@ -332,8 +324,8 @@ class AnyMeta(TypingMeta): self = super().__new__(cls, name, bases, namespace, _root=_root) return self - def __instancecheck__(self, instance): - return True + def __instancecheck__(self, obj): + raise TypeError("Any cannot be used with isinstance().") def __subclasscheck__(self, cls): if not isinstance(cls, type): @@ -447,7 +439,6 @@ KT = TypeVar('KT') # Key type. VT = TypeVar('VT') # Value type. T_co = TypeVar('T_co', covariant=True) # Any type covariant containers. V_co = TypeVar('V_co', covariant=True) # Any type covariant containers. -KT_co = TypeVar('KT_co', covariant=True) # Key type covariant containers. VT_co = TypeVar('VT_co', covariant=True) # Value type covariant containers. T_contra = TypeVar('T_contra', contravariant=True) # Ditto contravariant. @@ -548,9 +539,8 @@ class UnionMeta(TypingMeta): def __hash__(self): return hash(self.__union_set_params__) - def __instancecheck__(self, instance): - return (self.__union_set_params__ is not None and - any(isinstance(instance, t) for t in self.__union_params__)) + def __instancecheck__(self, obj): + raise TypeError("Unions cannot be used with isinstance().") def __subclasscheck__(self, cls): if cls is Any: @@ -709,18 +699,8 @@ class TupleMeta(TypingMeta): def __hash__(self): return hash(self.__tuple_params__) - def __instancecheck__(self, t): - if not isinstance(t, tuple): - return False - if self.__tuple_params__ is None: - return True - if self.__tuple_use_ellipsis__: - p = self.__tuple_params__[0] - return all(isinstance(x, p) for x in t) - else: - return (len(t) == len(self.__tuple_params__) and - all(isinstance(x, p) - for x, p in zip(t, self.__tuple_params__))) + def __instancecheck__(self, obj): + raise TypeError("Tuples cannot be used with isinstance().") def __subclasscheck__(self, cls): if cls is Any: @@ -826,57 +806,14 @@ class CallableMeta(TypingMeta): def __hash__(self): return hash(self.__args__) ^ hash(self.__result__) - def __instancecheck__(self, instance): - if not callable(instance): - return False + def __instancecheck__(self, obj): + # For unparametrized Callable we allow this, because + # typing.Callable should be equivalent to + # collections.abc.Callable. if self.__args__ is None and self.__result__ is None: - return True - assert self.__args__ is not None - assert self.__result__ is not None - my_args, my_result = self.__args__, self.__result__ - import inspect # TODO: Avoid this import. - # Would it be better to use Signature objects? - try: - (args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, - annotations) = inspect.getfullargspec(instance) - except TypeError: - return False # We can't find the signature. Give up. - msg = ("When testing isinstance(<callable>, Callable[...], " - "<calleble>'s annotations must be types.") - if my_args is not Ellipsis: - if kwonlyargs and (not kwonlydefaults or - len(kwonlydefaults) < len(kwonlyargs)): - return False - if isinstance(instance, types.MethodType): - # For methods, getfullargspec() includes self/cls, - # but it's not part of the call signature, so drop it. - del args[0] - min_call_args = len(args) - if defaults: - min_call_args -= len(defaults) - if varargs: - max_call_args = 999999999 - if len(args) < len(my_args): - args += [varargs] * (len(my_args) - len(args)) - else: - max_call_args = len(args) - if not min_call_args <= len(my_args) <= max_call_args: - return False - for my_arg_type, name in zip(my_args, args): - if name in annotations: - annot_type = _type_check(annotations[name], msg) - else: - annot_type = Any - if not issubclass(my_arg_type, annot_type): - return False - # TODO: If mutable type, check invariance? - if 'return' in annotations: - annot_return_type = _type_check(annotations['return'], msg) - # Note contravariance here! - if not issubclass(annot_return_type, my_result): - return False - # Can't find anything wrong... - return True + return isinstance(obj, collections_abc.Callable) + else: + raise TypeError("Callable[] cannot be used with isinstance().") def __subclasscheck__(self, cls): if cls is Any: @@ -1073,13 +1010,6 @@ class GenericMeta(TypingMeta, abc.ABCMeta): return False return issubclass(cls, self.__extra__) - def __instancecheck__(self, obj): - if super().__instancecheck__(obj): - return True - if self.__extra__ is None: - return False - return isinstance(obj, self.__extra__) - class Generic(metaclass=GenericMeta): """Abstract base class for generic types. @@ -1234,6 +1164,9 @@ class _ProtocolMeta(GenericMeta): from Generic. """ + def __instancecheck__(self, obj): + raise TypeError("Protocols cannot be used with isinstance().") + def __subclasscheck__(self, cls): if not self._is_protocol: # No structural checks since this isn't a protocol. @@ -1374,7 +1307,8 @@ class MutableSet(AbstractSet[T], extra=collections_abc.MutableSet): pass -class Mapping(Sized, Iterable[KT_co], Container[KT_co], Generic[KT_co, VT_co], +# NOTE: Only the value type is covariant. +class Mapping(Sized, Iterable[KT], Container[KT], Generic[KT, VT_co], extra=collections_abc.Mapping): pass @@ -1399,19 +1333,7 @@ class ByteString(Sequence[int], extra=collections_abc.ByteString): ByteString.register(type(memoryview(b''))) -class _ListMeta(GenericMeta): - - def __instancecheck__(self, obj): - if not super().__instancecheck__(obj): - return False - itemtype = self.__parameters__[0] - for x in obj: - if not isinstance(x, itemtype): - return False - return True - - -class List(list, MutableSequence[T], metaclass=_ListMeta): +class List(list, MutableSequence[T]): def __new__(cls, *args, **kwds): if _geqv(cls, List): @@ -1420,19 +1342,7 @@ class List(list, MutableSequence[T], metaclass=_ListMeta): return list.__new__(cls, *args, **kwds) -class _SetMeta(GenericMeta): - - def __instancecheck__(self, obj): - if not super().__instancecheck__(obj): - return False - itemtype = self.__parameters__[0] - for x in obj: - if not isinstance(x, itemtype): - return False - return True - - -class Set(set, MutableSet[T], metaclass=_SetMeta): +class Set(set, MutableSet[T]): def __new__(cls, *args, **kwds): if _geqv(cls, Set): @@ -1441,7 +1351,7 @@ class Set(set, MutableSet[T], metaclass=_SetMeta): return set.__new__(cls, *args, **kwds) -class _FrozenSetMeta(_SetMeta): +class _FrozenSetMeta(GenericMeta): """This metaclass ensures set is not a subclass of FrozenSet. Without this metaclass, set would be considered a subclass of @@ -1454,11 +1364,6 @@ class _FrozenSetMeta(_SetMeta): return False return super().__subclasscheck__(cls) - def __instancecheck__(self, obj): - if issubclass(obj.__class__, Set): - return False - return super().__instancecheck__(obj) - class FrozenSet(frozenset, AbstractSet[T_co], metaclass=_FrozenSetMeta): @@ -1473,13 +1378,13 @@ class MappingView(Sized, Iterable[T_co], extra=collections_abc.MappingView): pass -class KeysView(MappingView[KT_co], AbstractSet[KT_co], +class KeysView(MappingView[KT], AbstractSet[KT], extra=collections_abc.KeysView): pass -# TODO: Enable Set[Tuple[KT_co, VT_co]] instead of Generic[KT_co, VT_co]. -class ItemsView(MappingView, Generic[KT_co, VT_co], +# TODO: Enable Set[Tuple[KT, VT_co]] instead of Generic[KT, VT_co]. +class ItemsView(MappingView, Generic[KT, VT_co], extra=collections_abc.ItemsView): pass @@ -1488,20 +1393,7 @@ class ValuesView(MappingView[VT_co], extra=collections_abc.ValuesView): pass -class _DictMeta(GenericMeta): - - def __instancecheck__(self, obj): - if not super().__instancecheck__(obj): - return False - keytype, valuetype = self.__parameters__ - for key, value in obj.items(): - if not (isinstance(key, keytype) and - isinstance(value, valuetype)): - return False - return True - - -class Dict(dict, MutableMapping[KT, VT], metaclass=_DictMeta): +class Dict(dict, MutableMapping[KT, VT]): def __new__(cls, *args, **kwds): if _geqv(cls, Dict): @@ -2,6 +2,22 @@ Python News +++++++++++ +What's New in Python 3.6.0 alpha 1? +=================================== + +Release date: XXXX-XX-XX + +Core and Builtins +----------------- + +Library +------- + +- Issue #24426: Fast searching optimization in regular expressions now works + for patterns that starts with capturing groups. Fast searching optimization + now can't be disabled at compile time. + + What's New in Python 3.5.0 beta 3? ================================== @@ -154,6 +170,9 @@ Core and Builtins - Issue #24268: PEP 489: Multi-phase extension module initialization. Patch by Petr Viktorin. +- Issue #23359: Optimize set object internals by specializing the + hash table search into a lookup function and an insert function. + - Issue #23955: Add pyvenv.cfg option to suppress registry/environment lookup for generating sys.path on Windows. diff --git a/Modules/_sre.c b/Modules/_sre.c index 4f47393..1cc8bd8 100644 --- a/Modules/_sre.c +++ b/Modules/_sre.c @@ -62,9 +62,6 @@ static char copyright[] = /* -------------------------------------------------------------------- */ /* optional features */ -/* enables fast searching */ -#define USE_FAST_SEARCH - /* enables copy/deepcopy handling (work in progress) */ #undef USE_BUILTIN_COPY diff --git a/Modules/sre_lib.h b/Modules/sre_lib.h index 463a908..422f168 100644 --- a/Modules/sre_lib.h +++ b/Modules/sre_lib.h @@ -1248,7 +1248,32 @@ SRE(search)(SRE_STATE* state, SRE_CODE* pattern) prefix, prefix_len, prefix_skip)); TRACE(("charset = %p\n", charset)); -#if defined(USE_FAST_SEARCH) + if (prefix_len == 1) { + /* pattern starts with a literal character */ + SRE_CHAR c = (SRE_CHAR) prefix[0]; +#if SIZEOF_SRE_CHAR < 4 + if ((SRE_CODE) c != prefix[0]) + return 0; /* literal can't match: doesn't fit in char width */ +#endif + end = (SRE_CHAR *)state->end; + while (ptr < end) { + while (*ptr != c) { + if (++ptr >= end) + return 0; + } + TRACE(("|%p|%p|SEARCH LITERAL\n", pattern, ptr)); + state->start = ptr; + state->ptr = ptr + prefix_skip; + if (flags & SRE_INFO_LITERAL) + return 1; /* we got all of it */ + status = SRE(match)(state, pattern + 2*prefix_skip, 0); + if (status != 0) + return status; + ++ptr; + } + return 0; + } + if (prefix_len > 1) { /* pattern starts with a known prefix. use the overlap table to skip forward as fast as we possibly can */ @@ -1297,32 +1322,8 @@ SRE(search)(SRE_STATE* state, SRE_CODE* pattern) } return 0; } -#endif - if (pattern[0] == SRE_OP_LITERAL) { - /* pattern starts with a literal character. this is used - for short prefixes, and if fast search is disabled */ - SRE_CHAR c = (SRE_CHAR) pattern[1]; -#if SIZEOF_SRE_CHAR < 4 - if ((SRE_CODE) c != pattern[1]) - return 0; /* literal can't match: doesn't fit in char width */ -#endif - end = (SRE_CHAR *)state->end; - while (ptr < end) { - while (*ptr != c) { - if (++ptr >= end) - return 0; - } - TRACE(("|%p|%p|SEARCH LITERAL\n", pattern, ptr)); - state->start = ptr; - state->ptr = ++ptr; - if (flags & SRE_INFO_LITERAL) - return 1; /* we got all of it */ - status = SRE(match)(state, pattern + 2, 0); - if (status != 0) - break; - } - } else if (charset) { + if (charset) { /* pattern starts with a character from a known set */ end = (SRE_CHAR *)state->end; for (;;) { diff --git a/Objects/setobject.c b/Objects/setobject.c index d962c1e..09d1129 100644 --- a/Objects/setobject.c +++ b/Objects/setobject.c @@ -52,9 +52,8 @@ static setentry * set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash) { setentry *table = so->table; - setentry *freeslot = NULL; setentry *entry; - size_t perturb = hash; + size_t perturb; size_t mask = so->mask; size_t i = (size_t)hash & mask; /* Unsigned for defined overflow behavior */ size_t j; @@ -64,6 +63,8 @@ set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash) if (entry->key == NULL) return entry; + perturb = hash; + while (1) { if (entry->hash == hash) { PyObject *startkey = entry->key; @@ -86,14 +87,12 @@ set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash) return entry; mask = so->mask; /* help avoid a register spill */ } - if (entry->hash == -1 && freeslot == NULL) - freeslot = entry; if (i + LINEAR_PROBES <= mask) { for (j = 0 ; j < LINEAR_PROBES ; j++) { entry++; - if (entry->key == NULL) - goto found_null; + if (entry->hash == 0 && entry->key == NULL) + return entry; if (entry->hash == hash) { PyObject *startkey = entry->key; assert(startkey != dummy); @@ -114,7 +113,88 @@ set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash) return entry; mask = so->mask; } - if (entry->hash == -1 && freeslot == NULL) + } + } + + perturb >>= PERTURB_SHIFT; + i = (i * 5 + 1 + perturb) & mask; + + entry = &table[i]; + if (entry->key == NULL) + return entry; + } +} + +static int +set_insert_key(PySetObject *so, PyObject *key, Py_hash_t hash) +{ + setentry *table = so->table; + setentry *freeslot; + setentry *entry; + size_t perturb; + size_t mask = so->mask; + size_t i = (size_t)hash & mask; /* Unsigned for defined overflow behavior */ + size_t j; + int cmp; + + entry = &table[i]; + if (entry->key == NULL) + goto found_null_first; + + freeslot = NULL; + perturb = hash; + + while (1) { + if (entry->hash == hash) { + PyObject *startkey = entry->key; + /* startkey cannot be a dummy because the dummy hash field is -1 */ + assert(startkey != dummy); + if (startkey == key) + goto found_active; + if (PyUnicode_CheckExact(startkey) + && PyUnicode_CheckExact(key) + && unicode_eq(startkey, key)) + goto found_active; + Py_INCREF(startkey); + cmp = PyObject_RichCompareBool(startkey, key, Py_EQ); + Py_DECREF(startkey); + if (cmp < 0) /* unlikely */ + return -1; + if (table != so->table || entry->key != startkey) /* unlikely */ + return set_insert_key(so, key, hash); + if (cmp > 0) /* likely */ + goto found_active; + mask = so->mask; /* help avoid a register spill */ + } + if (entry->hash == -1 && freeslot == NULL) + freeslot = entry; + + if (i + LINEAR_PROBES <= mask) { + for (j = 0 ; j < LINEAR_PROBES ; j++) { + entry++; + if (entry->hash == 0 && entry->key == NULL) + goto found_null; + if (entry->hash == hash) { + PyObject *startkey = entry->key; + assert(startkey != dummy); + if (startkey == key) + goto found_active; + if (PyUnicode_CheckExact(startkey) + && PyUnicode_CheckExact(key) + && unicode_eq(startkey, key)) + goto found_active; + Py_INCREF(startkey); + cmp = PyObject_RichCompareBool(startkey, key, Py_EQ); + Py_DECREF(startkey); + if (cmp < 0) + return -1; + if (table != so->table || entry->key != startkey) + return set_insert_key(so, key, hash); + if (cmp > 0) + goto found_active; + mask = so->mask; + } + else if (entry->hash == -1 && freeslot == NULL) freeslot = entry; } } @@ -126,8 +206,31 @@ set_lookkey(PySetObject *so, PyObject *key, Py_hash_t hash) if (entry->key == NULL) goto found_null; } + + found_null_first: + Py_INCREF(key); + so->fill++; + so->used++; + entry->key = key; + entry->hash = hash; + return 0; + found_null: - return freeslot == NULL ? entry : freeslot; + Py_INCREF(key); + if (freeslot == NULL) { + /* UNUSED */ + so->fill++; + } else { + /* DUMMY */ + entry = freeslot; + } + so->used++; + entry->key = key; + entry->hash = hash; + return 0; + + found_active: + return 0; } /* @@ -172,38 +275,6 @@ set_insert_clean(PySetObject *so, PyObject *key, Py_hash_t hash) /* ======== End logic for probing the hash table ========================== */ /* ======================================================================== */ - -/* -Internal routine to insert a new key into the table. -Used by the public insert routine. -Eats a reference to key. -*/ -static int -set_insert_key(PySetObject *so, PyObject *key, Py_hash_t hash) -{ - setentry *entry; - - entry = set_lookkey(so, key, hash); - if (entry == NULL) - return -1; - if (entry->key == NULL) { - /* UNUSED */ - entry->key = key; - entry->hash = hash; - so->fill++; - so->used++; - } else if (entry->key == dummy) { - /* DUMMY */ - entry->key = key; - entry->hash = hash; - so->used++; - } else { - /* ACTIVE */ - Py_DECREF(key); - } - return 0; -} - /* Restructure the table by allocating a new table and reinserting all keys again. When entries have been deleted, the new table may @@ -306,11 +377,8 @@ set_add_entry(PySetObject *so, setentry *entry) assert(so->fill <= so->mask); /* at least one empty slot */ n_used = so->used; - Py_INCREF(key); - if (set_insert_key(so, key, hash)) { - Py_DECREF(key); + if (set_insert_key(so, key, hash)) return -1; - } if (!(so->used > n_used && so->fill*3 >= (so->mask+1)*2)) return 0; return set_table_resize(so, so->used>50000 ? so->used*2 : so->used*4); @@ -345,7 +413,7 @@ set_discard_entry(PySetObject *so, setentry *oldentry) entry = set_lookkey(so, oldentry->key, oldentry->hash); if (entry == NULL) return -1; - if (entry->key == NULL || entry->key == dummy) + if (entry->key == NULL) return DISCARD_NOTFOUND; old_key = entry->key; entry->key = dummy; @@ -603,11 +671,8 @@ set_merge(PySetObject *so, PyObject *otherset) for (i = 0; i <= other->mask; i++, other_entry++) { key = other_entry->key; if (key != NULL && key != dummy) { - Py_INCREF(key); - if (set_insert_key(so, key, other_entry->hash)) { - Py_DECREF(key); + if (set_insert_key(so, key, other_entry->hash)) return -1; - } } } return 0; @@ -623,7 +688,7 @@ set_contains_entry(PySetObject *so, setentry *entry) if (lu_entry == NULL) return -1; key = lu_entry->key; - return key != NULL && key != dummy; + return key != NULL; } static int diff --git a/PC/example_nt/example.vcproj b/PC/example_nt/example.vcproj index d82f76e..958eb78 100644 --- a/PC/example_nt/example.vcproj +++ b/PC/example_nt/example.vcproj @@ -39,7 +39,7 @@ <Tool
Name="VCLinkerTool"
AdditionalOptions="/export:initexample"
- AdditionalDependencies="odbc32.lib odbccp32.lib python35.lib"
+ AdditionalDependencies="odbc32.lib odbccp32.lib python36.lib"
OutputFile=".\Release/example.pyd"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
@@ -105,7 +105,7 @@ <Tool
Name="VCLinkerTool"
AdditionalOptions="/export:initexample"
- AdditionalDependencies="odbc32.lib odbccp32.lib python35_d.lib"
+ AdditionalDependencies="odbc32.lib odbccp32.lib python36_d.lib"
OutputFile=".\Debug/example_d.pyd"
LinkIncremental="1"
SuppressStartupBanner="TRUE"
diff --git a/PC/pyconfig.h b/PC/pyconfig.h index 324a130..40c9305 100644 --- a/PC/pyconfig.h +++ b/PC/pyconfig.h @@ -304,11 +304,11 @@ Py_NO_ENABLE_SHARED to find out. Also support MS_NO_COREDLL for b/w compat */ their Makefile (other compilers are generally taken care of by distutils.) */ # if defined(_DEBUG) -# pragma comment(lib,"python35_d.lib") +# pragma comment(lib,"python36_d.lib") # elif defined(Py_LIMITED_API) # pragma comment(lib,"python3.lib") # else -# pragma comment(lib,"python35.lib") +# pragma comment(lib,"python36.lib") # endif /* _DEBUG */ # endif /* _MSC_VER */ # endif /* Py_BUILD_CORE */ diff --git a/PC/python3.def b/PC/python3.def index 88c0742..e146e8f 100644 --- a/PC/python3.def +++ b/PC/python3.def @@ -2,712 +2,712 @@ ; It is used when building python3dll.vcxproj LIBRARY "python3" EXPORTS - PyArg_Parse=python35.PyArg_Parse - PyArg_ParseTuple=python35.PyArg_ParseTuple - PyArg_ParseTupleAndKeywords=python35.PyArg_ParseTupleAndKeywords - PyArg_UnpackTuple=python35.PyArg_UnpackTuple - PyArg_VaParse=python35.PyArg_VaParse - PyArg_VaParseTupleAndKeywords=python35.PyArg_VaParseTupleAndKeywords - PyArg_ValidateKeywordArguments=python35.PyArg_ValidateKeywordArguments - PyBaseObject_Type=python35.PyBaseObject_Type DATA - PyBool_FromLong=python35.PyBool_FromLong - PyBool_Type=python35.PyBool_Type DATA - PyByteArrayIter_Type=python35.PyByteArrayIter_Type DATA - PyByteArray_AsString=python35.PyByteArray_AsString - PyByteArray_Concat=python35.PyByteArray_Concat - PyByteArray_FromObject=python35.PyByteArray_FromObject - PyByteArray_FromStringAndSize=python35.PyByteArray_FromStringAndSize - PyByteArray_Resize=python35.PyByteArray_Resize - PyByteArray_Size=python35.PyByteArray_Size - PyByteArray_Type=python35.PyByteArray_Type DATA - PyBytesIter_Type=python35.PyBytesIter_Type DATA - PyBytes_AsString=python35.PyBytes_AsString - PyBytes_AsStringAndSize=python35.PyBytes_AsStringAndSize - PyBytes_Concat=python35.PyBytes_Concat - PyBytes_ConcatAndDel=python35.PyBytes_ConcatAndDel - PyBytes_DecodeEscape=python35.PyBytes_DecodeEscape - PyBytes_FromFormat=python35.PyBytes_FromFormat - PyBytes_FromFormatV=python35.PyBytes_FromFormatV - PyBytes_FromObject=python35.PyBytes_FromObject - PyBytes_FromString=python35.PyBytes_FromString - PyBytes_FromStringAndSize=python35.PyBytes_FromStringAndSize - PyBytes_Repr=python35.PyBytes_Repr - PyBytes_Size=python35.PyBytes_Size - PyBytes_Type=python35.PyBytes_Type DATA - PyCFunction_Call=python35.PyCFunction_Call - PyCFunction_ClearFreeList=python35.PyCFunction_ClearFreeList - PyCFunction_GetFlags=python35.PyCFunction_GetFlags - PyCFunction_GetFunction=python35.PyCFunction_GetFunction - PyCFunction_GetSelf=python35.PyCFunction_GetSelf - PyCFunction_New=python35.PyCFunction_New - PyCFunction_NewEx=python35.PyCFunction_NewEx - PyCFunction_Type=python35.PyCFunction_Type DATA - PyCallIter_New=python35.PyCallIter_New - PyCallIter_Type=python35.PyCallIter_Type DATA - PyCallable_Check=python35.PyCallable_Check - PyCapsule_GetContext=python35.PyCapsule_GetContext - PyCapsule_GetDestructor=python35.PyCapsule_GetDestructor - PyCapsule_GetName=python35.PyCapsule_GetName - PyCapsule_GetPointer=python35.PyCapsule_GetPointer - PyCapsule_Import=python35.PyCapsule_Import - PyCapsule_IsValid=python35.PyCapsule_IsValid - PyCapsule_New=python35.PyCapsule_New - PyCapsule_SetContext=python35.PyCapsule_SetContext - PyCapsule_SetDestructor=python35.PyCapsule_SetDestructor - PyCapsule_SetName=python35.PyCapsule_SetName - PyCapsule_SetPointer=python35.PyCapsule_SetPointer - PyCapsule_Type=python35.PyCapsule_Type DATA - PyClassMethodDescr_Type=python35.PyClassMethodDescr_Type DATA - PyCodec_BackslashReplaceErrors=python35.PyCodec_BackslashReplaceErrors - PyCodec_Decode=python35.PyCodec_Decode - PyCodec_Decoder=python35.PyCodec_Decoder - PyCodec_Encode=python35.PyCodec_Encode - PyCodec_Encoder=python35.PyCodec_Encoder - PyCodec_IgnoreErrors=python35.PyCodec_IgnoreErrors - PyCodec_IncrementalDecoder=python35.PyCodec_IncrementalDecoder - PyCodec_IncrementalEncoder=python35.PyCodec_IncrementalEncoder - PyCodec_KnownEncoding=python35.PyCodec_KnownEncoding - PyCodec_LookupError=python35.PyCodec_LookupError - PyCodec_Register=python35.PyCodec_Register - PyCodec_RegisterError=python35.PyCodec_RegisterError - PyCodec_ReplaceErrors=python35.PyCodec_ReplaceErrors - PyCodec_StreamReader=python35.PyCodec_StreamReader - PyCodec_StreamWriter=python35.PyCodec_StreamWriter - PyCodec_StrictErrors=python35.PyCodec_StrictErrors - PyCodec_XMLCharRefReplaceErrors=python35.PyCodec_XMLCharRefReplaceErrors - PyComplex_FromDoubles=python35.PyComplex_FromDoubles - PyComplex_ImagAsDouble=python35.PyComplex_ImagAsDouble - PyComplex_RealAsDouble=python35.PyComplex_RealAsDouble - PyComplex_Type=python35.PyComplex_Type DATA - PyDescr_NewClassMethod=python35.PyDescr_NewClassMethod - PyDescr_NewGetSet=python35.PyDescr_NewGetSet - PyDescr_NewMember=python35.PyDescr_NewMember - PyDescr_NewMethod=python35.PyDescr_NewMethod - PyDictItems_Type=python35.PyDictItems_Type DATA - PyDictIterItem_Type=python35.PyDictIterItem_Type DATA - PyDictIterKey_Type=python35.PyDictIterKey_Type DATA - PyDictIterValue_Type=python35.PyDictIterValue_Type DATA - PyDictKeys_Type=python35.PyDictKeys_Type DATA - PyDictProxy_New=python35.PyDictProxy_New - PyDictProxy_Type=python35.PyDictProxy_Type DATA - PyDictValues_Type=python35.PyDictValues_Type DATA - PyDict_Clear=python35.PyDict_Clear - PyDict_Contains=python35.PyDict_Contains - PyDict_Copy=python35.PyDict_Copy - PyDict_DelItem=python35.PyDict_DelItem - PyDict_DelItemString=python35.PyDict_DelItemString - PyDict_GetItem=python35.PyDict_GetItem - PyDict_GetItemString=python35.PyDict_GetItemString - PyDict_GetItemWithError=python35.PyDict_GetItemWithError - PyDict_Items=python35.PyDict_Items - PyDict_Keys=python35.PyDict_Keys - PyDict_Merge=python35.PyDict_Merge - PyDict_MergeFromSeq2=python35.PyDict_MergeFromSeq2 - PyDict_New=python35.PyDict_New - PyDict_Next=python35.PyDict_Next - PyDict_SetItem=python35.PyDict_SetItem - PyDict_SetItemString=python35.PyDict_SetItemString - PyDict_Size=python35.PyDict_Size - PyDict_Type=python35.PyDict_Type DATA - PyDict_Update=python35.PyDict_Update - PyDict_Values=python35.PyDict_Values - PyEllipsis_Type=python35.PyEllipsis_Type DATA - PyEnum_Type=python35.PyEnum_Type DATA - PyErr_BadArgument=python35.PyErr_BadArgument - PyErr_BadInternalCall=python35.PyErr_BadInternalCall - PyErr_CheckSignals=python35.PyErr_CheckSignals - PyErr_Clear=python35.PyErr_Clear - PyErr_Display=python35.PyErr_Display - PyErr_ExceptionMatches=python35.PyErr_ExceptionMatches - PyErr_Fetch=python35.PyErr_Fetch - PyErr_Format=python35.PyErr_Format - PyErr_FormatV=python35.PyErr_FormatV - PyErr_GivenExceptionMatches=python35.PyErr_GivenExceptionMatches - PyErr_NewException=python35.PyErr_NewException - PyErr_NewExceptionWithDoc=python35.PyErr_NewExceptionWithDoc - PyErr_NoMemory=python35.PyErr_NoMemory - PyErr_NormalizeException=python35.PyErr_NormalizeException - PyErr_Occurred=python35.PyErr_Occurred - PyErr_Print=python35.PyErr_Print - PyErr_PrintEx=python35.PyErr_PrintEx - PyErr_ProgramText=python35.PyErr_ProgramText - PyErr_Restore=python35.PyErr_Restore - PyErr_SetFromErrno=python35.PyErr_SetFromErrno - PyErr_SetFromErrnoWithFilename=python35.PyErr_SetFromErrnoWithFilename - PyErr_SetFromErrnoWithFilenameObject=python35.PyErr_SetFromErrnoWithFilenameObject - PyErr_SetInterrupt=python35.PyErr_SetInterrupt - PyErr_SetNone=python35.PyErr_SetNone - PyErr_SetObject=python35.PyErr_SetObject - PyErr_SetString=python35.PyErr_SetString - PyErr_SyntaxLocation=python35.PyErr_SyntaxLocation - PyErr_WarnEx=python35.PyErr_WarnEx - PyErr_WarnExplicit=python35.PyErr_WarnExplicit - PyErr_WarnFormat=python35.PyErr_WarnFormat - PyErr_WriteUnraisable=python35.PyErr_WriteUnraisable - PyEval_AcquireLock=python35.PyEval_AcquireLock - PyEval_AcquireThread=python35.PyEval_AcquireThread - PyEval_CallFunction=python35.PyEval_CallFunction - PyEval_CallMethod=python35.PyEval_CallMethod - PyEval_CallObjectWithKeywords=python35.PyEval_CallObjectWithKeywords - PyEval_EvalCode=python35.PyEval_EvalCode - PyEval_EvalCodeEx=python35.PyEval_EvalCodeEx - PyEval_EvalFrame=python35.PyEval_EvalFrame - PyEval_EvalFrameEx=python35.PyEval_EvalFrameEx - PyEval_GetBuiltins=python35.PyEval_GetBuiltins - PyEval_GetCallStats=python35.PyEval_GetCallStats - PyEval_GetFrame=python35.PyEval_GetFrame - PyEval_GetFuncDesc=python35.PyEval_GetFuncDesc - PyEval_GetFuncName=python35.PyEval_GetFuncName - PyEval_GetGlobals=python35.PyEval_GetGlobals - PyEval_GetLocals=python35.PyEval_GetLocals - PyEval_InitThreads=python35.PyEval_InitThreads - PyEval_ReInitThreads=python35.PyEval_ReInitThreads - PyEval_ReleaseLock=python35.PyEval_ReleaseLock - PyEval_ReleaseThread=python35.PyEval_ReleaseThread - PyEval_RestoreThread=python35.PyEval_RestoreThread - PyEval_SaveThread=python35.PyEval_SaveThread - PyEval_ThreadsInitialized=python35.PyEval_ThreadsInitialized - PyExc_ArithmeticError=python35.PyExc_ArithmeticError DATA - PyExc_AssertionError=python35.PyExc_AssertionError DATA - PyExc_AttributeError=python35.PyExc_AttributeError DATA - PyExc_BaseException=python35.PyExc_BaseException DATA - PyExc_BufferError=python35.PyExc_BufferError DATA - PyExc_BytesWarning=python35.PyExc_BytesWarning DATA - PyExc_DeprecationWarning=python35.PyExc_DeprecationWarning DATA - PyExc_EOFError=python35.PyExc_EOFError DATA - PyExc_EnvironmentError=python35.PyExc_EnvironmentError DATA - PyExc_Exception=python35.PyExc_Exception DATA - PyExc_FloatingPointError=python35.PyExc_FloatingPointError DATA - PyExc_FutureWarning=python35.PyExc_FutureWarning DATA - PyExc_GeneratorExit=python35.PyExc_GeneratorExit DATA - PyExc_IOError=python35.PyExc_IOError DATA - PyExc_ImportError=python35.PyExc_ImportError DATA - PyExc_ImportWarning=python35.PyExc_ImportWarning DATA - PyExc_IndentationError=python35.PyExc_IndentationError DATA - PyExc_IndexError=python35.PyExc_IndexError DATA - PyExc_KeyError=python35.PyExc_KeyError DATA - PyExc_KeyboardInterrupt=python35.PyExc_KeyboardInterrupt DATA - PyExc_LookupError=python35.PyExc_LookupError DATA - PyExc_MemoryError=python35.PyExc_MemoryError DATA - PyExc_MemoryErrorInst=python35.PyExc_MemoryErrorInst DATA - PyExc_NameError=python35.PyExc_NameError DATA - PyExc_NotImplementedError=python35.PyExc_NotImplementedError DATA - PyExc_OSError=python35.PyExc_OSError DATA - PyExc_OverflowError=python35.PyExc_OverflowError DATA - PyExc_PendingDeprecationWarning=python35.PyExc_PendingDeprecationWarning DATA - PyExc_RecursionErrorInst=python35.PyExc_RecursionErrorInst DATA - PyExc_ReferenceError=python35.PyExc_ReferenceError DATA - PyExc_RuntimeError=python35.PyExc_RuntimeError DATA - PyExc_RuntimeWarning=python35.PyExc_RuntimeWarning DATA - PyExc_StopIteration=python35.PyExc_StopIteration DATA - PyExc_SyntaxError=python35.PyExc_SyntaxError DATA - PyExc_SyntaxWarning=python35.PyExc_SyntaxWarning DATA - PyExc_SystemError=python35.PyExc_SystemError DATA - PyExc_SystemExit=python35.PyExc_SystemExit DATA - PyExc_TabError=python35.PyExc_TabError DATA - PyExc_TypeError=python35.PyExc_TypeError DATA - PyExc_UnboundLocalError=python35.PyExc_UnboundLocalError DATA - PyExc_UnicodeDecodeError=python35.PyExc_UnicodeDecodeError DATA - PyExc_UnicodeEncodeError=python35.PyExc_UnicodeEncodeError DATA - PyExc_UnicodeError=python35.PyExc_UnicodeError DATA - PyExc_UnicodeTranslateError=python35.PyExc_UnicodeTranslateError DATA - PyExc_UnicodeWarning=python35.PyExc_UnicodeWarning DATA - PyExc_UserWarning=python35.PyExc_UserWarning DATA - PyExc_ValueError=python35.PyExc_ValueError DATA - PyExc_Warning=python35.PyExc_Warning DATA - PyExc_ZeroDivisionError=python35.PyExc_ZeroDivisionError DATA - PyException_GetCause=python35.PyException_GetCause - PyException_GetContext=python35.PyException_GetContext - PyException_GetTraceback=python35.PyException_GetTraceback - PyException_SetCause=python35.PyException_SetCause - PyException_SetContext=python35.PyException_SetContext - PyException_SetTraceback=python35.PyException_SetTraceback - PyFile_FromFd=python35.PyFile_FromFd - PyFile_GetLine=python35.PyFile_GetLine - PyFile_WriteObject=python35.PyFile_WriteObject - PyFile_WriteString=python35.PyFile_WriteString - PyFilter_Type=python35.PyFilter_Type DATA - PyFloat_AsDouble=python35.PyFloat_AsDouble - PyFloat_FromDouble=python35.PyFloat_FromDouble - PyFloat_FromString=python35.PyFloat_FromString - PyFloat_GetInfo=python35.PyFloat_GetInfo - PyFloat_GetMax=python35.PyFloat_GetMax - PyFloat_GetMin=python35.PyFloat_GetMin - PyFloat_Type=python35.PyFloat_Type DATA - PyFrozenSet_New=python35.PyFrozenSet_New - PyFrozenSet_Type=python35.PyFrozenSet_Type DATA - PyGC_Collect=python35.PyGC_Collect - PyGILState_Ensure=python35.PyGILState_Ensure - PyGILState_GetThisThreadState=python35.PyGILState_GetThisThreadState - PyGILState_Release=python35.PyGILState_Release - PyGetSetDescr_Type=python35.PyGetSetDescr_Type DATA - PyImport_AddModule=python35.PyImport_AddModule - PyImport_AppendInittab=python35.PyImport_AppendInittab - PyImport_Cleanup=python35.PyImport_Cleanup - PyImport_ExecCodeModule=python35.PyImport_ExecCodeModule - PyImport_ExecCodeModuleEx=python35.PyImport_ExecCodeModuleEx - PyImport_ExecCodeModuleWithPathnames=python35.PyImport_ExecCodeModuleWithPathnames - PyImport_GetImporter=python35.PyImport_GetImporter - PyImport_GetMagicNumber=python35.PyImport_GetMagicNumber - PyImport_GetMagicTag=python35.PyImport_GetMagicTag - PyImport_GetModuleDict=python35.PyImport_GetModuleDict - PyImport_Import=python35.PyImport_Import - PyImport_ImportFrozenModule=python35.PyImport_ImportFrozenModule - PyImport_ImportModule=python35.PyImport_ImportModule - PyImport_ImportModuleLevel=python35.PyImport_ImportModuleLevel - PyImport_ImportModuleNoBlock=python35.PyImport_ImportModuleNoBlock - PyImport_ReloadModule=python35.PyImport_ReloadModule - PyInterpreterState_Clear=python35.PyInterpreterState_Clear - PyInterpreterState_Delete=python35.PyInterpreterState_Delete - PyInterpreterState_New=python35.PyInterpreterState_New - PyIter_Next=python35.PyIter_Next - PyListIter_Type=python35.PyListIter_Type DATA - PyListRevIter_Type=python35.PyListRevIter_Type DATA - PyList_Append=python35.PyList_Append - PyList_AsTuple=python35.PyList_AsTuple - PyList_GetItem=python35.PyList_GetItem - PyList_GetSlice=python35.PyList_GetSlice - PyList_Insert=python35.PyList_Insert - PyList_New=python35.PyList_New - PyList_Reverse=python35.PyList_Reverse - PyList_SetItem=python35.PyList_SetItem - PyList_SetSlice=python35.PyList_SetSlice - PyList_Size=python35.PyList_Size - PyList_Sort=python35.PyList_Sort - PyList_Type=python35.PyList_Type DATA - PyLongRangeIter_Type=python35.PyLongRangeIter_Type DATA - PyLong_AsDouble=python35.PyLong_AsDouble - PyLong_AsLong=python35.PyLong_AsLong - PyLong_AsLongAndOverflow=python35.PyLong_AsLongAndOverflow - PyLong_AsLongLong=python35.PyLong_AsLongLong - PyLong_AsLongLongAndOverflow=python35.PyLong_AsLongLongAndOverflow - PyLong_AsSize_t=python35.PyLong_AsSize_t - PyLong_AsSsize_t=python35.PyLong_AsSsize_t - PyLong_AsUnsignedLong=python35.PyLong_AsUnsignedLong - PyLong_AsUnsignedLongLong=python35.PyLong_AsUnsignedLongLong - PyLong_AsUnsignedLongLongMask=python35.PyLong_AsUnsignedLongLongMask - PyLong_AsUnsignedLongMask=python35.PyLong_AsUnsignedLongMask - PyLong_AsVoidPtr=python35.PyLong_AsVoidPtr - PyLong_FromDouble=python35.PyLong_FromDouble - PyLong_FromLong=python35.PyLong_FromLong - PyLong_FromLongLong=python35.PyLong_FromLongLong - PyLong_FromSize_t=python35.PyLong_FromSize_t - PyLong_FromSsize_t=python35.PyLong_FromSsize_t - PyLong_FromString=python35.PyLong_FromString - PyLong_FromUnsignedLong=python35.PyLong_FromUnsignedLong - PyLong_FromUnsignedLongLong=python35.PyLong_FromUnsignedLongLong - PyLong_FromVoidPtr=python35.PyLong_FromVoidPtr - PyLong_GetInfo=python35.PyLong_GetInfo - PyLong_Type=python35.PyLong_Type DATA - PyMap_Type=python35.PyMap_Type DATA - PyMapping_Check=python35.PyMapping_Check - PyMapping_GetItemString=python35.PyMapping_GetItemString - PyMapping_HasKey=python35.PyMapping_HasKey - PyMapping_HasKeyString=python35.PyMapping_HasKeyString - PyMapping_Items=python35.PyMapping_Items - PyMapping_Keys=python35.PyMapping_Keys - PyMapping_Length=python35.PyMapping_Length - PyMapping_SetItemString=python35.PyMapping_SetItemString - PyMapping_Size=python35.PyMapping_Size - PyMapping_Values=python35.PyMapping_Values - PyMem_Free=python35.PyMem_Free - PyMem_Malloc=python35.PyMem_Malloc - PyMem_Realloc=python35.PyMem_Realloc - PyMemberDescr_Type=python35.PyMemberDescr_Type DATA - PyMemoryView_FromObject=python35.PyMemoryView_FromObject - PyMemoryView_GetContiguous=python35.PyMemoryView_GetContiguous - PyMemoryView_Type=python35.PyMemoryView_Type DATA - PyMethodDescr_Type=python35.PyMethodDescr_Type DATA - PyModule_AddIntConstant=python35.PyModule_AddIntConstant - PyModule_AddObject=python35.PyModule_AddObject - PyModule_AddStringConstant=python35.PyModule_AddStringConstant - PyModule_Create2=python35.PyModule_Create2 - PyModule_GetDef=python35.PyModule_GetDef - PyModule_GetDict=python35.PyModule_GetDict - PyModule_GetFilename=python35.PyModule_GetFilename - PyModule_GetFilenameObject=python35.PyModule_GetFilenameObject - PyModule_GetName=python35.PyModule_GetName - PyModule_GetState=python35.PyModule_GetState - PyModule_New=python35.PyModule_New - PyModule_Type=python35.PyModule_Type DATA - PyModuleDef_Init=python35.PyModuleDef_Init - PyModuleDef_Type=python35.PyModuleDef_Type DATA - PyNullImporter_Type=python35.PyNullImporter_Type DATA - PyNumber_Absolute=python35.PyNumber_Absolute - PyNumber_Add=python35.PyNumber_Add - PyNumber_And=python35.PyNumber_And - PyNumber_AsSsize_t=python35.PyNumber_AsSsize_t - PyNumber_Check=python35.PyNumber_Check - PyNumber_Divmod=python35.PyNumber_Divmod - PyNumber_Float=python35.PyNumber_Float - PyNumber_FloorDivide=python35.PyNumber_FloorDivide - PyNumber_InPlaceAdd=python35.PyNumber_InPlaceAdd - PyNumber_InPlaceAnd=python35.PyNumber_InPlaceAnd - PyNumber_InPlaceFloorDivide=python35.PyNumber_InPlaceFloorDivide - PyNumber_InPlaceLshift=python35.PyNumber_InPlaceLshift - PyNumber_InPlaceMultiply=python35.PyNumber_InPlaceMultiply - PyNumber_InPlaceOr=python35.PyNumber_InPlaceOr - PyNumber_InPlacePower=python35.PyNumber_InPlacePower - PyNumber_InPlaceRemainder=python35.PyNumber_InPlaceRemainder - PyNumber_InPlaceRshift=python35.PyNumber_InPlaceRshift - PyNumber_InPlaceSubtract=python35.PyNumber_InPlaceSubtract - PyNumber_InPlaceTrueDivide=python35.PyNumber_InPlaceTrueDivide - PyNumber_InPlaceXor=python35.PyNumber_InPlaceXor - PyNumber_Index=python35.PyNumber_Index - PyNumber_Invert=python35.PyNumber_Invert - PyNumber_Long=python35.PyNumber_Long - PyNumber_Lshift=python35.PyNumber_Lshift - PyNumber_Multiply=python35.PyNumber_Multiply - PyNumber_Negative=python35.PyNumber_Negative - PyNumber_Or=python35.PyNumber_Or - PyNumber_Positive=python35.PyNumber_Positive - PyNumber_Power=python35.PyNumber_Power - PyNumber_Remainder=python35.PyNumber_Remainder - PyNumber_Rshift=python35.PyNumber_Rshift - PyNumber_Subtract=python35.PyNumber_Subtract - PyNumber_ToBase=python35.PyNumber_ToBase - PyNumber_TrueDivide=python35.PyNumber_TrueDivide - PyNumber_Xor=python35.PyNumber_Xor - PyOS_AfterFork=python35.PyOS_AfterFork - PyOS_InitInterrupts=python35.PyOS_InitInterrupts - PyOS_InputHook=python35.PyOS_InputHook DATA - PyOS_InterruptOccurred=python35.PyOS_InterruptOccurred - PyOS_ReadlineFunctionPointer=python35.PyOS_ReadlineFunctionPointer DATA - PyOS_double_to_string=python35.PyOS_double_to_string - PyOS_getsig=python35.PyOS_getsig - PyOS_mystricmp=python35.PyOS_mystricmp - PyOS_mystrnicmp=python35.PyOS_mystrnicmp - PyOS_setsig=python35.PyOS_setsig - PyOS_snprintf=python35.PyOS_snprintf - PyOS_string_to_double=python35.PyOS_string_to_double - PyOS_strtol=python35.PyOS_strtol - PyOS_strtoul=python35.PyOS_strtoul - PyOS_vsnprintf=python35.PyOS_vsnprintf - PyObject_ASCII=python35.PyObject_ASCII - PyObject_AsCharBuffer=python35.PyObject_AsCharBuffer - PyObject_AsFileDescriptor=python35.PyObject_AsFileDescriptor - PyObject_AsReadBuffer=python35.PyObject_AsReadBuffer - PyObject_AsWriteBuffer=python35.PyObject_AsWriteBuffer - PyObject_Bytes=python35.PyObject_Bytes - PyObject_Call=python35.PyObject_Call - PyObject_CallFunction=python35.PyObject_CallFunction - PyObject_CallFunctionObjArgs=python35.PyObject_CallFunctionObjArgs - PyObject_CallMethod=python35.PyObject_CallMethod - PyObject_CallMethodObjArgs=python35.PyObject_CallMethodObjArgs - PyObject_CallObject=python35.PyObject_CallObject - PyObject_CheckReadBuffer=python35.PyObject_CheckReadBuffer - PyObject_ClearWeakRefs=python35.PyObject_ClearWeakRefs - PyObject_DelItem=python35.PyObject_DelItem - PyObject_DelItemString=python35.PyObject_DelItemString - PyObject_Dir=python35.PyObject_Dir - PyObject_Format=python35.PyObject_Format - PyObject_Free=python35.PyObject_Free - PyObject_GC_Del=python35.PyObject_GC_Del - PyObject_GC_Track=python35.PyObject_GC_Track - PyObject_GC_UnTrack=python35.PyObject_GC_UnTrack - PyObject_GenericGetAttr=python35.PyObject_GenericGetAttr - PyObject_GenericSetAttr=python35.PyObject_GenericSetAttr - PyObject_GetAttr=python35.PyObject_GetAttr - PyObject_GetAttrString=python35.PyObject_GetAttrString - PyObject_GetItem=python35.PyObject_GetItem - PyObject_GetIter=python35.PyObject_GetIter - PyObject_HasAttr=python35.PyObject_HasAttr - PyObject_HasAttrString=python35.PyObject_HasAttrString - PyObject_Hash=python35.PyObject_Hash - PyObject_HashNotImplemented=python35.PyObject_HashNotImplemented - PyObject_Init=python35.PyObject_Init - PyObject_InitVar=python35.PyObject_InitVar - PyObject_IsInstance=python35.PyObject_IsInstance - PyObject_IsSubclass=python35.PyObject_IsSubclass - PyObject_IsTrue=python35.PyObject_IsTrue - PyObject_Length=python35.PyObject_Length - PyObject_Malloc=python35.PyObject_Malloc - PyObject_Not=python35.PyObject_Not - PyObject_Realloc=python35.PyObject_Realloc - PyObject_Repr=python35.PyObject_Repr - PyObject_RichCompare=python35.PyObject_RichCompare - PyObject_RichCompareBool=python35.PyObject_RichCompareBool - PyObject_SelfIter=python35.PyObject_SelfIter - PyObject_SetAttr=python35.PyObject_SetAttr - PyObject_SetAttrString=python35.PyObject_SetAttrString - PyObject_SetItem=python35.PyObject_SetItem - PyObject_Size=python35.PyObject_Size - PyObject_Str=python35.PyObject_Str - PyObject_Type=python35.PyObject_Type DATA - PyODict_DelItem=python35.PyODict_DelItem - PyODict_New=python35.PyODict_New - PyODict_SetItem=python35.PyODict_SetItem - PyODict_Type=python35.PyODict_Type DATA - PyODictItems_Type=python35.PyODictItems_Type DATA - PyODictIter_Type=python35.PyODictIter_Type DATA - PyODictKeys_Type=python35.PyODictKeys_Type DATA - PyODictValues_Type=python35.PyODictValues_Type DATA - PyParser_SimpleParseFileFlags=python35.PyParser_SimpleParseFileFlags - PyParser_SimpleParseStringFlags=python35.PyParser_SimpleParseStringFlags - PyProperty_Type=python35.PyProperty_Type DATA - PyRangeIter_Type=python35.PyRangeIter_Type DATA - PyRange_Type=python35.PyRange_Type DATA - PyReversed_Type=python35.PyReversed_Type DATA - PySeqIter_New=python35.PySeqIter_New - PySeqIter_Type=python35.PySeqIter_Type DATA - PySequence_Check=python35.PySequence_Check - PySequence_Concat=python35.PySequence_Concat - PySequence_Contains=python35.PySequence_Contains - PySequence_Count=python35.PySequence_Count - PySequence_DelItem=python35.PySequence_DelItem - PySequence_DelSlice=python35.PySequence_DelSlice - PySequence_Fast=python35.PySequence_Fast - PySequence_GetItem=python35.PySequence_GetItem - PySequence_GetSlice=python35.PySequence_GetSlice - PySequence_In=python35.PySequence_In - PySequence_InPlaceConcat=python35.PySequence_InPlaceConcat - PySequence_InPlaceRepeat=python35.PySequence_InPlaceRepeat - PySequence_Index=python35.PySequence_Index - PySequence_Length=python35.PySequence_Length - PySequence_List=python35.PySequence_List - PySequence_Repeat=python35.PySequence_Repeat - PySequence_SetItem=python35.PySequence_SetItem - PySequence_SetSlice=python35.PySequence_SetSlice - PySequence_Size=python35.PySequence_Size - PySequence_Tuple=python35.PySequence_Tuple - PySetIter_Type=python35.PySetIter_Type DATA - PySet_Add=python35.PySet_Add - PySet_Clear=python35.PySet_Clear - PySet_Contains=python35.PySet_Contains - PySet_Discard=python35.PySet_Discard - PySet_New=python35.PySet_New - PySet_Pop=python35.PySet_Pop - PySet_Size=python35.PySet_Size - PySet_Type=python35.PySet_Type DATA - PySlice_GetIndices=python35.PySlice_GetIndices - PySlice_GetIndicesEx=python35.PySlice_GetIndicesEx - PySlice_New=python35.PySlice_New - PySlice_Type=python35.PySlice_Type DATA - PySortWrapper_Type=python35.PySortWrapper_Type DATA - PyState_FindModule=python35.PyState_FindModule - PyState_AddModule=python35.PyState_AddModule - PyState_RemoveModule=python35.PyState_RemoveModule - PyStructSequence_GetItem=python35.PyStructSequence_GetItem - PyStructSequence_New=python35.PyStructSequence_New - PyStructSequence_NewType=python35.PyStructSequence_NewType - PyStructSequence_SetItem=python35.PyStructSequence_SetItem - PySuper_Type=python35.PySuper_Type DATA - PySys_AddWarnOption=python35.PySys_AddWarnOption - PySys_AddWarnOptionUnicode=python35.PySys_AddWarnOptionUnicode - PySys_FormatStderr=python35.PySys_FormatStderr - PySys_FormatStdout=python35.PySys_FormatStdout - PySys_GetObject=python35.PySys_GetObject - PySys_HasWarnOptions=python35.PySys_HasWarnOptions - PySys_ResetWarnOptions=python35.PySys_ResetWarnOptions - PySys_SetArgv=python35.PySys_SetArgv - PySys_SetArgvEx=python35.PySys_SetArgvEx - PySys_SetObject=python35.PySys_SetObject - PySys_SetPath=python35.PySys_SetPath - PySys_WriteStderr=python35.PySys_WriteStderr - PySys_WriteStdout=python35.PySys_WriteStdout - PyThreadState_Clear=python35.PyThreadState_Clear - PyThreadState_Delete=python35.PyThreadState_Delete - PyThreadState_DeleteCurrent=python35.PyThreadState_DeleteCurrent - PyThreadState_Get=python35.PyThreadState_Get - PyThreadState_GetDict=python35.PyThreadState_GetDict - PyThreadState_New=python35.PyThreadState_New - PyThreadState_SetAsyncExc=python35.PyThreadState_SetAsyncExc - PyThreadState_Swap=python35.PyThreadState_Swap - PyTraceBack_Here=python35.PyTraceBack_Here - PyTraceBack_Print=python35.PyTraceBack_Print - PyTraceBack_Type=python35.PyTraceBack_Type DATA - PyTupleIter_Type=python35.PyTupleIter_Type DATA - PyTuple_ClearFreeList=python35.PyTuple_ClearFreeList - PyTuple_GetItem=python35.PyTuple_GetItem - PyTuple_GetSlice=python35.PyTuple_GetSlice - PyTuple_New=python35.PyTuple_New - PyTuple_Pack=python35.PyTuple_Pack - PyTuple_SetItem=python35.PyTuple_SetItem - PyTuple_Size=python35.PyTuple_Size - PyTuple_Type=python35.PyTuple_Type DATA - PyType_ClearCache=python35.PyType_ClearCache - PyType_FromSpec=python35.PyType_FromSpec - PyType_FromSpecWithBases=python35.PyType_FromSpecWithBases - PyType_GenericAlloc=python35.PyType_GenericAlloc - PyType_GenericNew=python35.PyType_GenericNew - PyType_GetFlags=python35.PyType_GetFlags - PyType_GetSlot=python35.PyType_GetSlot - PyType_IsSubtype=python35.PyType_IsSubtype - PyType_Modified=python35.PyType_Modified - PyType_Ready=python35.PyType_Ready - PyType_Type=python35.PyType_Type DATA - PyUnicodeDecodeError_Create=python35.PyUnicodeDecodeError_Create - PyUnicodeDecodeError_GetEncoding=python35.PyUnicodeDecodeError_GetEncoding - PyUnicodeDecodeError_GetEnd=python35.PyUnicodeDecodeError_GetEnd - PyUnicodeDecodeError_GetObject=python35.PyUnicodeDecodeError_GetObject - PyUnicodeDecodeError_GetReason=python35.PyUnicodeDecodeError_GetReason - PyUnicodeDecodeError_GetStart=python35.PyUnicodeDecodeError_GetStart - PyUnicodeDecodeError_SetEnd=python35.PyUnicodeDecodeError_SetEnd - PyUnicodeDecodeError_SetReason=python35.PyUnicodeDecodeError_SetReason - PyUnicodeDecodeError_SetStart=python35.PyUnicodeDecodeError_SetStart - PyUnicodeEncodeError_GetEncoding=python35.PyUnicodeEncodeError_GetEncoding - PyUnicodeEncodeError_GetEnd=python35.PyUnicodeEncodeError_GetEnd - PyUnicodeEncodeError_GetObject=python35.PyUnicodeEncodeError_GetObject - PyUnicodeEncodeError_GetReason=python35.PyUnicodeEncodeError_GetReason - PyUnicodeEncodeError_GetStart=python35.PyUnicodeEncodeError_GetStart - PyUnicodeEncodeError_SetEnd=python35.PyUnicodeEncodeError_SetEnd - PyUnicodeEncodeError_SetReason=python35.PyUnicodeEncodeError_SetReason - PyUnicodeEncodeError_SetStart=python35.PyUnicodeEncodeError_SetStart - PyUnicodeIter_Type=python35.PyUnicodeIter_Type DATA - PyUnicodeTranslateError_GetEnd=python35.PyUnicodeTranslateError_GetEnd - PyUnicodeTranslateError_GetObject=python35.PyUnicodeTranslateError_GetObject - PyUnicodeTranslateError_GetReason=python35.PyUnicodeTranslateError_GetReason - PyUnicodeTranslateError_GetStart=python35.PyUnicodeTranslateError_GetStart - PyUnicodeTranslateError_SetEnd=python35.PyUnicodeTranslateError_SetEnd - PyUnicodeTranslateError_SetReason=python35.PyUnicodeTranslateError_SetReason - PyUnicodeTranslateError_SetStart=python35.PyUnicodeTranslateError_SetStart - PyUnicode_Append=python35.PyUnicode_Append - PyUnicode_AppendAndDel=python35.PyUnicode_AppendAndDel - PyUnicode_AsASCIIString=python35.PyUnicode_AsASCIIString - PyUnicode_AsCharmapString=python35.PyUnicode_AsCharmapString - PyUnicode_AsDecodedObject=python35.PyUnicode_AsDecodedObject - PyUnicode_AsDecodedUnicode=python35.PyUnicode_AsDecodedUnicode - PyUnicode_AsEncodedObject=python35.PyUnicode_AsEncodedObject - PyUnicode_AsEncodedString=python35.PyUnicode_AsEncodedString - PyUnicode_AsEncodedUnicode=python35.PyUnicode_AsEncodedUnicode - PyUnicode_AsLatin1String=python35.PyUnicode_AsLatin1String - PyUnicode_AsRawUnicodeEscapeString=python35.PyUnicode_AsRawUnicodeEscapeString - PyUnicode_AsUTF16String=python35.PyUnicode_AsUTF16String - PyUnicode_AsUTF32String=python35.PyUnicode_AsUTF32String - PyUnicode_AsUTF8String=python35.PyUnicode_AsUTF8String - PyUnicode_AsUnicodeEscapeString=python35.PyUnicode_AsUnicodeEscapeString - PyUnicode_AsWideChar=python35.PyUnicode_AsWideChar - PyUnicode_ClearFreelist=python35.PyUnicode_ClearFreelist - PyUnicode_Compare=python35.PyUnicode_Compare - PyUnicode_Concat=python35.PyUnicode_Concat - PyUnicode_Contains=python35.PyUnicode_Contains - PyUnicode_Count=python35.PyUnicode_Count - PyUnicode_Decode=python35.PyUnicode_Decode - PyUnicode_DecodeASCII=python35.PyUnicode_DecodeASCII - PyUnicode_DecodeCharmap=python35.PyUnicode_DecodeCharmap - PyUnicode_DecodeFSDefault=python35.PyUnicode_DecodeFSDefault - PyUnicode_DecodeFSDefaultAndSize=python35.PyUnicode_DecodeFSDefaultAndSize - PyUnicode_DecodeLatin1=python35.PyUnicode_DecodeLatin1 - PyUnicode_DecodeRawUnicodeEscape=python35.PyUnicode_DecodeRawUnicodeEscape - PyUnicode_DecodeUTF16=python35.PyUnicode_DecodeUTF16 - PyUnicode_DecodeUTF16Stateful=python35.PyUnicode_DecodeUTF16Stateful - PyUnicode_DecodeUTF32=python35.PyUnicode_DecodeUTF32 - PyUnicode_DecodeUTF32Stateful=python35.PyUnicode_DecodeUTF32Stateful - PyUnicode_DecodeUTF8=python35.PyUnicode_DecodeUTF8 - PyUnicode_DecodeUTF8Stateful=python35.PyUnicode_DecodeUTF8Stateful - PyUnicode_DecodeUnicodeEscape=python35.PyUnicode_DecodeUnicodeEscape - PyUnicode_FSConverter=python35.PyUnicode_FSConverter - PyUnicode_FSDecoder=python35.PyUnicode_FSDecoder - PyUnicode_Find=python35.PyUnicode_Find - PyUnicode_Format=python35.PyUnicode_Format - PyUnicode_FromEncodedObject=python35.PyUnicode_FromEncodedObject - PyUnicode_FromFormat=python35.PyUnicode_FromFormat - PyUnicode_FromFormatV=python35.PyUnicode_FromFormatV - PyUnicode_FromObject=python35.PyUnicode_FromObject - PyUnicode_FromOrdinal=python35.PyUnicode_FromOrdinal - PyUnicode_FromString=python35.PyUnicode_FromString - PyUnicode_FromStringAndSize=python35.PyUnicode_FromStringAndSize - PyUnicode_FromWideChar=python35.PyUnicode_FromWideChar - PyUnicode_GetDefaultEncoding=python35.PyUnicode_GetDefaultEncoding - PyUnicode_GetSize=python35.PyUnicode_GetSize - PyUnicode_IsIdentifier=python35.PyUnicode_IsIdentifier - PyUnicode_Join=python35.PyUnicode_Join - PyUnicode_Partition=python35.PyUnicode_Partition - PyUnicode_RPartition=python35.PyUnicode_RPartition - PyUnicode_RSplit=python35.PyUnicode_RSplit - PyUnicode_Replace=python35.PyUnicode_Replace - PyUnicode_Resize=python35.PyUnicode_Resize - PyUnicode_RichCompare=python35.PyUnicode_RichCompare - PyUnicode_SetDefaultEncoding=python35.PyUnicode_SetDefaultEncoding - PyUnicode_Split=python35.PyUnicode_Split - PyUnicode_Splitlines=python35.PyUnicode_Splitlines - PyUnicode_Tailmatch=python35.PyUnicode_Tailmatch - PyUnicode_Translate=python35.PyUnicode_Translate - PyUnicode_BuildEncodingMap=python35.PyUnicode_BuildEncodingMap - PyUnicode_CompareWithASCIIString=python35.PyUnicode_CompareWithASCIIString - PyUnicode_DecodeUTF7=python35.PyUnicode_DecodeUTF7 - PyUnicode_DecodeUTF7Stateful=python35.PyUnicode_DecodeUTF7Stateful - PyUnicode_EncodeFSDefault=python35.PyUnicode_EncodeFSDefault - PyUnicode_InternFromString=python35.PyUnicode_InternFromString - PyUnicode_InternImmortal=python35.PyUnicode_InternImmortal - PyUnicode_InternInPlace=python35.PyUnicode_InternInPlace - PyUnicode_Type=python35.PyUnicode_Type DATA - PyWeakref_GetObject=python35.PyWeakref_GetObject DATA - PyWeakref_NewProxy=python35.PyWeakref_NewProxy - PyWeakref_NewRef=python35.PyWeakref_NewRef - PyWrapperDescr_Type=python35.PyWrapperDescr_Type DATA - PyWrapper_New=python35.PyWrapper_New - PyZip_Type=python35.PyZip_Type DATA - Py_AddPendingCall=python35.Py_AddPendingCall - Py_AtExit=python35.Py_AtExit - Py_BuildValue=python35.Py_BuildValue - Py_CompileString=python35.Py_CompileString - Py_DecRef=python35.Py_DecRef - Py_EndInterpreter=python35.Py_EndInterpreter - Py_Exit=python35.Py_Exit - Py_FatalError=python35.Py_FatalError - Py_FileSystemDefaultEncoding=python35.Py_FileSystemDefaultEncoding DATA - Py_Finalize=python35.Py_Finalize - Py_GetBuildInfo=python35.Py_GetBuildInfo - Py_GetCompiler=python35.Py_GetCompiler - Py_GetCopyright=python35.Py_GetCopyright - Py_GetExecPrefix=python35.Py_GetExecPrefix - Py_GetPath=python35.Py_GetPath - Py_GetPlatform=python35.Py_GetPlatform - Py_GetPrefix=python35.Py_GetPrefix - Py_GetProgramFullPath=python35.Py_GetProgramFullPath - Py_GetProgramName=python35.Py_GetProgramName - Py_GetPythonHome=python35.Py_GetPythonHome - Py_GetRecursionLimit=python35.Py_GetRecursionLimit - Py_GetVersion=python35.Py_GetVersion - Py_HasFileSystemDefaultEncoding=python35.Py_HasFileSystemDefaultEncoding DATA - Py_IncRef=python35.Py_IncRef - Py_Initialize=python35.Py_Initialize - Py_InitializeEx=python35.Py_InitializeEx - Py_IsInitialized=python35.Py_IsInitialized - Py_Main=python35.Py_Main - Py_MakePendingCalls=python35.Py_MakePendingCalls - Py_NewInterpreter=python35.Py_NewInterpreter - Py_ReprEnter=python35.Py_ReprEnter - Py_ReprLeave=python35.Py_ReprLeave - Py_SetProgramName=python35.Py_SetProgramName - Py_SetPythonHome=python35.Py_SetPythonHome - Py_SetRecursionLimit=python35.Py_SetRecursionLimit - Py_SymtableString=python35.Py_SymtableString - Py_VaBuildValue=python35.Py_VaBuildValue - _PyErr_BadInternalCall=python35._PyErr_BadInternalCall - _PyObject_CallFunction_SizeT=python35._PyObject_CallFunction_SizeT - _PyObject_CallMethod_SizeT=python35._PyObject_CallMethod_SizeT - _PyObject_GC_Malloc=python35._PyObject_GC_Malloc - _PyObject_GC_New=python35._PyObject_GC_New - _PyObject_GC_NewVar=python35._PyObject_GC_NewVar - _PyObject_GC_Resize=python35._PyObject_GC_Resize - _PyObject_New=python35._PyObject_New - _PyObject_NewVar=python35._PyObject_NewVar - _PyState_AddModule=python35._PyState_AddModule - _PyThreadState_Init=python35._PyThreadState_Init - _PyThreadState_Prealloc=python35._PyThreadState_Prealloc - _PyTrash_delete_later=python35._PyTrash_delete_later DATA - _PyTrash_delete_nesting=python35._PyTrash_delete_nesting DATA - _PyTrash_deposit_object=python35._PyTrash_deposit_object - _PyTrash_destroy_chain=python35._PyTrash_destroy_chain - _PyWeakref_CallableProxyType=python35._PyWeakref_CallableProxyType DATA - _PyWeakref_ProxyType=python35._PyWeakref_ProxyType DATA - _PyWeakref_RefType=python35._PyWeakref_RefType DATA - _Py_BuildValue_SizeT=python35._Py_BuildValue_SizeT - _Py_CheckRecursionLimit=python35._Py_CheckRecursionLimit DATA - _Py_CheckRecursiveCall=python35._Py_CheckRecursiveCall - _Py_Dealloc=python35._Py_Dealloc - _Py_EllipsisObject=python35._Py_EllipsisObject DATA - _Py_FalseStruct=python35._Py_FalseStruct DATA - _Py_NoneStruct=python35._Py_NoneStruct DATA - _Py_NotImplementedStruct=python35._Py_NotImplementedStruct DATA - _Py_SwappedOp=python35._Py_SwappedOp DATA - _Py_TrueStruct=python35._Py_TrueStruct DATA - _Py_VaBuildValue_SizeT=python35._Py_VaBuildValue_SizeT - _PyArg_Parse_SizeT=python35._PyArg_Parse_SizeT - _PyArg_ParseTuple_SizeT=python35._PyArg_ParseTuple_SizeT - _PyArg_ParseTupleAndKeywords_SizeT=python35._PyArg_ParseTupleAndKeywords_SizeT - _PyArg_VaParse_SizeT=python35._PyArg_VaParse_SizeT - _PyArg_VaParseTupleAndKeywords_SizeT=python35._PyArg_VaParseTupleAndKeywords_SizeT - _Py_BuildValue_SizeT=python35._Py_BuildValue_SizeT + PyArg_Parse=python36.PyArg_Parse + PyArg_ParseTuple=python36.PyArg_ParseTuple + PyArg_ParseTupleAndKeywords=python36.PyArg_ParseTupleAndKeywords + PyArg_UnpackTuple=python36.PyArg_UnpackTuple + PyArg_VaParse=python36.PyArg_VaParse + PyArg_VaParseTupleAndKeywords=python36.PyArg_VaParseTupleAndKeywords + PyArg_ValidateKeywordArguments=python36.PyArg_ValidateKeywordArguments + PyBaseObject_Type=python36.PyBaseObject_Type DATA + PyBool_FromLong=python36.PyBool_FromLong + PyBool_Type=python36.PyBool_Type DATA + PyByteArrayIter_Type=python36.PyByteArrayIter_Type DATA + PyByteArray_AsString=python36.PyByteArray_AsString + PyByteArray_Concat=python36.PyByteArray_Concat + PyByteArray_FromObject=python36.PyByteArray_FromObject + PyByteArray_FromStringAndSize=python36.PyByteArray_FromStringAndSize + PyByteArray_Resize=python36.PyByteArray_Resize + PyByteArray_Size=python36.PyByteArray_Size + PyByteArray_Type=python36.PyByteArray_Type DATA + PyBytesIter_Type=python36.PyBytesIter_Type DATA + PyBytes_AsString=python36.PyBytes_AsString + PyBytes_AsStringAndSize=python36.PyBytes_AsStringAndSize + PyBytes_Concat=python36.PyBytes_Concat + PyBytes_ConcatAndDel=python36.PyBytes_ConcatAndDel + PyBytes_DecodeEscape=python36.PyBytes_DecodeEscape + PyBytes_FromFormat=python36.PyBytes_FromFormat + PyBytes_FromFormatV=python36.PyBytes_FromFormatV + PyBytes_FromObject=python36.PyBytes_FromObject + PyBytes_FromString=python36.PyBytes_FromString + PyBytes_FromStringAndSize=python36.PyBytes_FromStringAndSize + PyBytes_Repr=python36.PyBytes_Repr + PyBytes_Size=python36.PyBytes_Size + PyBytes_Type=python36.PyBytes_Type DATA + PyCFunction_Call=python36.PyCFunction_Call + PyCFunction_ClearFreeList=python36.PyCFunction_ClearFreeList + PyCFunction_GetFlags=python36.PyCFunction_GetFlags + PyCFunction_GetFunction=python36.PyCFunction_GetFunction + PyCFunction_GetSelf=python36.PyCFunction_GetSelf + PyCFunction_New=python36.PyCFunction_New + PyCFunction_NewEx=python36.PyCFunction_NewEx + PyCFunction_Type=python36.PyCFunction_Type DATA + PyCallIter_New=python36.PyCallIter_New + PyCallIter_Type=python36.PyCallIter_Type DATA + PyCallable_Check=python36.PyCallable_Check + PyCapsule_GetContext=python36.PyCapsule_GetContext + PyCapsule_GetDestructor=python36.PyCapsule_GetDestructor + PyCapsule_GetName=python36.PyCapsule_GetName + PyCapsule_GetPointer=python36.PyCapsule_GetPointer + PyCapsule_Import=python36.PyCapsule_Import + PyCapsule_IsValid=python36.PyCapsule_IsValid + PyCapsule_New=python36.PyCapsule_New + PyCapsule_SetContext=python36.PyCapsule_SetContext + PyCapsule_SetDestructor=python36.PyCapsule_SetDestructor + PyCapsule_SetName=python36.PyCapsule_SetName + PyCapsule_SetPointer=python36.PyCapsule_SetPointer + PyCapsule_Type=python36.PyCapsule_Type DATA + PyClassMethodDescr_Type=python36.PyClassMethodDescr_Type DATA + PyCodec_BackslashReplaceErrors=python36.PyCodec_BackslashReplaceErrors + PyCodec_Decode=python36.PyCodec_Decode + PyCodec_Decoder=python36.PyCodec_Decoder + PyCodec_Encode=python36.PyCodec_Encode + PyCodec_Encoder=python36.PyCodec_Encoder + PyCodec_IgnoreErrors=python36.PyCodec_IgnoreErrors + PyCodec_IncrementalDecoder=python36.PyCodec_IncrementalDecoder + PyCodec_IncrementalEncoder=python36.PyCodec_IncrementalEncoder + PyCodec_KnownEncoding=python36.PyCodec_KnownEncoding + PyCodec_LookupError=python36.PyCodec_LookupError + PyCodec_Register=python36.PyCodec_Register + PyCodec_RegisterError=python36.PyCodec_RegisterError + PyCodec_ReplaceErrors=python36.PyCodec_ReplaceErrors + PyCodec_StreamReader=python36.PyCodec_StreamReader + PyCodec_StreamWriter=python36.PyCodec_StreamWriter + PyCodec_StrictErrors=python36.PyCodec_StrictErrors + PyCodec_XMLCharRefReplaceErrors=python36.PyCodec_XMLCharRefReplaceErrors + PyComplex_FromDoubles=python36.PyComplex_FromDoubles + PyComplex_ImagAsDouble=python36.PyComplex_ImagAsDouble + PyComplex_RealAsDouble=python36.PyComplex_RealAsDouble + PyComplex_Type=python36.PyComplex_Type DATA + PyDescr_NewClassMethod=python36.PyDescr_NewClassMethod + PyDescr_NewGetSet=python36.PyDescr_NewGetSet + PyDescr_NewMember=python36.PyDescr_NewMember + PyDescr_NewMethod=python36.PyDescr_NewMethod + PyDictItems_Type=python36.PyDictItems_Type DATA + PyDictIterItem_Type=python36.PyDictIterItem_Type DATA + PyDictIterKey_Type=python36.PyDictIterKey_Type DATA + PyDictIterValue_Type=python36.PyDictIterValue_Type DATA + PyDictKeys_Type=python36.PyDictKeys_Type DATA + PyDictProxy_New=python36.PyDictProxy_New + PyDictProxy_Type=python36.PyDictProxy_Type DATA + PyDictValues_Type=python36.PyDictValues_Type DATA + PyDict_Clear=python36.PyDict_Clear + PyDict_Contains=python36.PyDict_Contains + PyDict_Copy=python36.PyDict_Copy + PyDict_DelItem=python36.PyDict_DelItem + PyDict_DelItemString=python36.PyDict_DelItemString + PyDict_GetItem=python36.PyDict_GetItem + PyDict_GetItemString=python36.PyDict_GetItemString + PyDict_GetItemWithError=python36.PyDict_GetItemWithError + PyDict_Items=python36.PyDict_Items + PyDict_Keys=python36.PyDict_Keys + PyDict_Merge=python36.PyDict_Merge + PyDict_MergeFromSeq2=python36.PyDict_MergeFromSeq2 + PyDict_New=python36.PyDict_New + PyDict_Next=python36.PyDict_Next + PyDict_SetItem=python36.PyDict_SetItem + PyDict_SetItemString=python36.PyDict_SetItemString + PyDict_Size=python36.PyDict_Size + PyDict_Type=python36.PyDict_Type DATA + PyDict_Update=python36.PyDict_Update + PyDict_Values=python36.PyDict_Values + PyEllipsis_Type=python36.PyEllipsis_Type DATA + PyEnum_Type=python36.PyEnum_Type DATA + PyErr_BadArgument=python36.PyErr_BadArgument + PyErr_BadInternalCall=python36.PyErr_BadInternalCall + PyErr_CheckSignals=python36.PyErr_CheckSignals + PyErr_Clear=python36.PyErr_Clear + PyErr_Display=python36.PyErr_Display + PyErr_ExceptionMatches=python36.PyErr_ExceptionMatches + PyErr_Fetch=python36.PyErr_Fetch + PyErr_Format=python36.PyErr_Format + PyErr_FormatV=python36.PyErr_FormatV + PyErr_GivenExceptionMatches=python36.PyErr_GivenExceptionMatches + PyErr_NewException=python36.PyErr_NewException + PyErr_NewExceptionWithDoc=python36.PyErr_NewExceptionWithDoc + PyErr_NoMemory=python36.PyErr_NoMemory + PyErr_NormalizeException=python36.PyErr_NormalizeException + PyErr_Occurred=python36.PyErr_Occurred + PyErr_Print=python36.PyErr_Print + PyErr_PrintEx=python36.PyErr_PrintEx + PyErr_ProgramText=python36.PyErr_ProgramText + PyErr_Restore=python36.PyErr_Restore + PyErr_SetFromErrno=python36.PyErr_SetFromErrno + PyErr_SetFromErrnoWithFilename=python36.PyErr_SetFromErrnoWithFilename + PyErr_SetFromErrnoWithFilenameObject=python36.PyErr_SetFromErrnoWithFilenameObject + PyErr_SetInterrupt=python36.PyErr_SetInterrupt + PyErr_SetNone=python36.PyErr_SetNone + PyErr_SetObject=python36.PyErr_SetObject + PyErr_SetString=python36.PyErr_SetString + PyErr_SyntaxLocation=python36.PyErr_SyntaxLocation + PyErr_WarnEx=python36.PyErr_WarnEx + PyErr_WarnExplicit=python36.PyErr_WarnExplicit + PyErr_WarnFormat=python36.PyErr_WarnFormat + PyErr_WriteUnraisable=python36.PyErr_WriteUnraisable + PyEval_AcquireLock=python36.PyEval_AcquireLock + PyEval_AcquireThread=python36.PyEval_AcquireThread + PyEval_CallFunction=python36.PyEval_CallFunction + PyEval_CallMethod=python36.PyEval_CallMethod + PyEval_CallObjectWithKeywords=python36.PyEval_CallObjectWithKeywords + PyEval_EvalCode=python36.PyEval_EvalCode + PyEval_EvalCodeEx=python36.PyEval_EvalCodeEx + PyEval_EvalFrame=python36.PyEval_EvalFrame + PyEval_EvalFrameEx=python36.PyEval_EvalFrameEx + PyEval_GetBuiltins=python36.PyEval_GetBuiltins + PyEval_GetCallStats=python36.PyEval_GetCallStats + PyEval_GetFrame=python36.PyEval_GetFrame + PyEval_GetFuncDesc=python36.PyEval_GetFuncDesc + PyEval_GetFuncName=python36.PyEval_GetFuncName + PyEval_GetGlobals=python36.PyEval_GetGlobals + PyEval_GetLocals=python36.PyEval_GetLocals + PyEval_InitThreads=python36.PyEval_InitThreads + PyEval_ReInitThreads=python36.PyEval_ReInitThreads + PyEval_ReleaseLock=python36.PyEval_ReleaseLock + PyEval_ReleaseThread=python36.PyEval_ReleaseThread + PyEval_RestoreThread=python36.PyEval_RestoreThread + PyEval_SaveThread=python36.PyEval_SaveThread + PyEval_ThreadsInitialized=python36.PyEval_ThreadsInitialized + PyExc_ArithmeticError=python36.PyExc_ArithmeticError DATA + PyExc_AssertionError=python36.PyExc_AssertionError DATA + PyExc_AttributeError=python36.PyExc_AttributeError DATA + PyExc_BaseException=python36.PyExc_BaseException DATA + PyExc_BufferError=python36.PyExc_BufferError DATA + PyExc_BytesWarning=python36.PyExc_BytesWarning DATA + PyExc_DeprecationWarning=python36.PyExc_DeprecationWarning DATA + PyExc_EOFError=python36.PyExc_EOFError DATA + PyExc_EnvironmentError=python36.PyExc_EnvironmentError DATA + PyExc_Exception=python36.PyExc_Exception DATA + PyExc_FloatingPointError=python36.PyExc_FloatingPointError DATA + PyExc_FutureWarning=python36.PyExc_FutureWarning DATA + PyExc_GeneratorExit=python36.PyExc_GeneratorExit DATA + PyExc_IOError=python36.PyExc_IOError DATA + PyExc_ImportError=python36.PyExc_ImportError DATA + PyExc_ImportWarning=python36.PyExc_ImportWarning DATA + PyExc_IndentationError=python36.PyExc_IndentationError DATA + PyExc_IndexError=python36.PyExc_IndexError DATA + PyExc_KeyError=python36.PyExc_KeyError DATA + PyExc_KeyboardInterrupt=python36.PyExc_KeyboardInterrupt DATA + PyExc_LookupError=python36.PyExc_LookupError DATA + PyExc_MemoryError=python36.PyExc_MemoryError DATA + PyExc_MemoryErrorInst=python36.PyExc_MemoryErrorInst DATA + PyExc_NameError=python36.PyExc_NameError DATA + PyExc_NotImplementedError=python36.PyExc_NotImplementedError DATA + PyExc_OSError=python36.PyExc_OSError DATA + PyExc_OverflowError=python36.PyExc_OverflowError DATA + PyExc_PendingDeprecationWarning=python36.PyExc_PendingDeprecationWarning DATA + PyExc_RecursionErrorInst=python36.PyExc_RecursionErrorInst DATA + PyExc_ReferenceError=python36.PyExc_ReferenceError DATA + PyExc_RuntimeError=python36.PyExc_RuntimeError DATA + PyExc_RuntimeWarning=python36.PyExc_RuntimeWarning DATA + PyExc_StopIteration=python36.PyExc_StopIteration DATA + PyExc_SyntaxError=python36.PyExc_SyntaxError DATA + PyExc_SyntaxWarning=python36.PyExc_SyntaxWarning DATA + PyExc_SystemError=python36.PyExc_SystemError DATA + PyExc_SystemExit=python36.PyExc_SystemExit DATA + PyExc_TabError=python36.PyExc_TabError DATA + PyExc_TypeError=python36.PyExc_TypeError DATA + PyExc_UnboundLocalError=python36.PyExc_UnboundLocalError DATA + PyExc_UnicodeDecodeError=python36.PyExc_UnicodeDecodeError DATA + PyExc_UnicodeEncodeError=python36.PyExc_UnicodeEncodeError DATA + PyExc_UnicodeError=python36.PyExc_UnicodeError DATA + PyExc_UnicodeTranslateError=python36.PyExc_UnicodeTranslateError DATA + PyExc_UnicodeWarning=python36.PyExc_UnicodeWarning DATA + PyExc_UserWarning=python36.PyExc_UserWarning DATA + PyExc_ValueError=python36.PyExc_ValueError DATA + PyExc_Warning=python36.PyExc_Warning DATA + PyExc_ZeroDivisionError=python36.PyExc_ZeroDivisionError DATA + PyException_GetCause=python36.PyException_GetCause + PyException_GetContext=python36.PyException_GetContext + PyException_GetTraceback=python36.PyException_GetTraceback + PyException_SetCause=python36.PyException_SetCause + PyException_SetContext=python36.PyException_SetContext + PyException_SetTraceback=python36.PyException_SetTraceback + PyFile_FromFd=python36.PyFile_FromFd + PyFile_GetLine=python36.PyFile_GetLine + PyFile_WriteObject=python36.PyFile_WriteObject + PyFile_WriteString=python36.PyFile_WriteString + PyFilter_Type=python36.PyFilter_Type DATA + PyFloat_AsDouble=python36.PyFloat_AsDouble + PyFloat_FromDouble=python36.PyFloat_FromDouble + PyFloat_FromString=python36.PyFloat_FromString + PyFloat_GetInfo=python36.PyFloat_GetInfo + PyFloat_GetMax=python36.PyFloat_GetMax + PyFloat_GetMin=python36.PyFloat_GetMin + PyFloat_Type=python36.PyFloat_Type DATA + PyFrozenSet_New=python36.PyFrozenSet_New + PyFrozenSet_Type=python36.PyFrozenSet_Type DATA + PyGC_Collect=python36.PyGC_Collect + PyGILState_Ensure=python36.PyGILState_Ensure + PyGILState_GetThisThreadState=python36.PyGILState_GetThisThreadState + PyGILState_Release=python36.PyGILState_Release + PyGetSetDescr_Type=python36.PyGetSetDescr_Type DATA + PyImport_AddModule=python36.PyImport_AddModule + PyImport_AppendInittab=python36.PyImport_AppendInittab + PyImport_Cleanup=python36.PyImport_Cleanup + PyImport_ExecCodeModule=python36.PyImport_ExecCodeModule + PyImport_ExecCodeModuleEx=python36.PyImport_ExecCodeModuleEx + PyImport_ExecCodeModuleWithPathnames=python36.PyImport_ExecCodeModuleWithPathnames + PyImport_GetImporter=python36.PyImport_GetImporter + PyImport_GetMagicNumber=python36.PyImport_GetMagicNumber + PyImport_GetMagicTag=python36.PyImport_GetMagicTag + PyImport_GetModuleDict=python36.PyImport_GetModuleDict + PyImport_Import=python36.PyImport_Import + PyImport_ImportFrozenModule=python36.PyImport_ImportFrozenModule + PyImport_ImportModule=python36.PyImport_ImportModule + PyImport_ImportModuleLevel=python36.PyImport_ImportModuleLevel + PyImport_ImportModuleNoBlock=python36.PyImport_ImportModuleNoBlock + PyImport_ReloadModule=python36.PyImport_ReloadModule + PyInterpreterState_Clear=python36.PyInterpreterState_Clear + PyInterpreterState_Delete=python36.PyInterpreterState_Delete + PyInterpreterState_New=python36.PyInterpreterState_New + PyIter_Next=python36.PyIter_Next + PyListIter_Type=python36.PyListIter_Type DATA + PyListRevIter_Type=python36.PyListRevIter_Type DATA + PyList_Append=python36.PyList_Append + PyList_AsTuple=python36.PyList_AsTuple + PyList_GetItem=python36.PyList_GetItem + PyList_GetSlice=python36.PyList_GetSlice + PyList_Insert=python36.PyList_Insert + PyList_New=python36.PyList_New + PyList_Reverse=python36.PyList_Reverse + PyList_SetItem=python36.PyList_SetItem + PyList_SetSlice=python36.PyList_SetSlice + PyList_Size=python36.PyList_Size + PyList_Sort=python36.PyList_Sort + PyList_Type=python36.PyList_Type DATA + PyLongRangeIter_Type=python36.PyLongRangeIter_Type DATA + PyLong_AsDouble=python36.PyLong_AsDouble + PyLong_AsLong=python36.PyLong_AsLong + PyLong_AsLongAndOverflow=python36.PyLong_AsLongAndOverflow + PyLong_AsLongLong=python36.PyLong_AsLongLong + PyLong_AsLongLongAndOverflow=python36.PyLong_AsLongLongAndOverflow + PyLong_AsSize_t=python36.PyLong_AsSize_t + PyLong_AsSsize_t=python36.PyLong_AsSsize_t + PyLong_AsUnsignedLong=python36.PyLong_AsUnsignedLong + PyLong_AsUnsignedLongLong=python36.PyLong_AsUnsignedLongLong + PyLong_AsUnsignedLongLongMask=python36.PyLong_AsUnsignedLongLongMask + PyLong_AsUnsignedLongMask=python36.PyLong_AsUnsignedLongMask + PyLong_AsVoidPtr=python36.PyLong_AsVoidPtr + PyLong_FromDouble=python36.PyLong_FromDouble + PyLong_FromLong=python36.PyLong_FromLong + PyLong_FromLongLong=python36.PyLong_FromLongLong + PyLong_FromSize_t=python36.PyLong_FromSize_t + PyLong_FromSsize_t=python36.PyLong_FromSsize_t + PyLong_FromString=python36.PyLong_FromString + PyLong_FromUnsignedLong=python36.PyLong_FromUnsignedLong + PyLong_FromUnsignedLongLong=python36.PyLong_FromUnsignedLongLong + PyLong_FromVoidPtr=python36.PyLong_FromVoidPtr + PyLong_GetInfo=python36.PyLong_GetInfo + PyLong_Type=python36.PyLong_Type DATA + PyMap_Type=python36.PyMap_Type DATA + PyMapping_Check=python36.PyMapping_Check + PyMapping_GetItemString=python36.PyMapping_GetItemString + PyMapping_HasKey=python36.PyMapping_HasKey + PyMapping_HasKeyString=python36.PyMapping_HasKeyString + PyMapping_Items=python36.PyMapping_Items + PyMapping_Keys=python36.PyMapping_Keys + PyMapping_Length=python36.PyMapping_Length + PyMapping_SetItemString=python36.PyMapping_SetItemString + PyMapping_Size=python36.PyMapping_Size + PyMapping_Values=python36.PyMapping_Values + PyMem_Free=python36.PyMem_Free + PyMem_Malloc=python36.PyMem_Malloc + PyMem_Realloc=python36.PyMem_Realloc + PyMemberDescr_Type=python36.PyMemberDescr_Type DATA + PyMemoryView_FromObject=python36.PyMemoryView_FromObject + PyMemoryView_GetContiguous=python36.PyMemoryView_GetContiguous + PyMemoryView_Type=python36.PyMemoryView_Type DATA + PyMethodDescr_Type=python36.PyMethodDescr_Type DATA + PyModule_AddIntConstant=python36.PyModule_AddIntConstant + PyModule_AddObject=python36.PyModule_AddObject + PyModule_AddStringConstant=python36.PyModule_AddStringConstant + PyModule_Create2=python36.PyModule_Create2 + PyModule_GetDef=python36.PyModule_GetDef + PyModule_GetDict=python36.PyModule_GetDict + PyModule_GetFilename=python36.PyModule_GetFilename + PyModule_GetFilenameObject=python36.PyModule_GetFilenameObject + PyModule_GetName=python36.PyModule_GetName + PyModule_GetState=python36.PyModule_GetState + PyModule_New=python36.PyModule_New + PyModule_Type=python36.PyModule_Type DATA + PyModuleDef_Init=python36.PyModuleDef_Init + PyModuleDef_Type=python36.PyModuleDef_Type DATA + PyNullImporter_Type=python36.PyNullImporter_Type DATA + PyNumber_Absolute=python36.PyNumber_Absolute + PyNumber_Add=python36.PyNumber_Add + PyNumber_And=python36.PyNumber_And + PyNumber_AsSsize_t=python36.PyNumber_AsSsize_t + PyNumber_Check=python36.PyNumber_Check + PyNumber_Divmod=python36.PyNumber_Divmod + PyNumber_Float=python36.PyNumber_Float + PyNumber_FloorDivide=python36.PyNumber_FloorDivide + PyNumber_InPlaceAdd=python36.PyNumber_InPlaceAdd + PyNumber_InPlaceAnd=python36.PyNumber_InPlaceAnd + PyNumber_InPlaceFloorDivide=python36.PyNumber_InPlaceFloorDivide + PyNumber_InPlaceLshift=python36.PyNumber_InPlaceLshift + PyNumber_InPlaceMultiply=python36.PyNumber_InPlaceMultiply + PyNumber_InPlaceOr=python36.PyNumber_InPlaceOr + PyNumber_InPlacePower=python36.PyNumber_InPlacePower + PyNumber_InPlaceRemainder=python36.PyNumber_InPlaceRemainder + PyNumber_InPlaceRshift=python36.PyNumber_InPlaceRshift + PyNumber_InPlaceSubtract=python36.PyNumber_InPlaceSubtract + PyNumber_InPlaceTrueDivide=python36.PyNumber_InPlaceTrueDivide + PyNumber_InPlaceXor=python36.PyNumber_InPlaceXor + PyNumber_Index=python36.PyNumber_Index + PyNumber_Invert=python36.PyNumber_Invert + PyNumber_Long=python36.PyNumber_Long + PyNumber_Lshift=python36.PyNumber_Lshift + PyNumber_Multiply=python36.PyNumber_Multiply + PyNumber_Negative=python36.PyNumber_Negative + PyNumber_Or=python36.PyNumber_Or + PyNumber_Positive=python36.PyNumber_Positive + PyNumber_Power=python36.PyNumber_Power + PyNumber_Remainder=python36.PyNumber_Remainder + PyNumber_Rshift=python36.PyNumber_Rshift + PyNumber_Subtract=python36.PyNumber_Subtract + PyNumber_ToBase=python36.PyNumber_ToBase + PyNumber_TrueDivide=python36.PyNumber_TrueDivide + PyNumber_Xor=python36.PyNumber_Xor + PyOS_AfterFork=python36.PyOS_AfterFork + PyOS_InitInterrupts=python36.PyOS_InitInterrupts + PyOS_InputHook=python36.PyOS_InputHook DATA + PyOS_InterruptOccurred=python36.PyOS_InterruptOccurred + PyOS_ReadlineFunctionPointer=python36.PyOS_ReadlineFunctionPointer DATA + PyOS_double_to_string=python36.PyOS_double_to_string + PyOS_getsig=python36.PyOS_getsig + PyOS_mystricmp=python36.PyOS_mystricmp + PyOS_mystrnicmp=python36.PyOS_mystrnicmp + PyOS_setsig=python36.PyOS_setsig + PyOS_snprintf=python36.PyOS_snprintf + PyOS_string_to_double=python36.PyOS_string_to_double + PyOS_strtol=python36.PyOS_strtol + PyOS_strtoul=python36.PyOS_strtoul + PyOS_vsnprintf=python36.PyOS_vsnprintf + PyObject_ASCII=python36.PyObject_ASCII + PyObject_AsCharBuffer=python36.PyObject_AsCharBuffer + PyObject_AsFileDescriptor=python36.PyObject_AsFileDescriptor + PyObject_AsReadBuffer=python36.PyObject_AsReadBuffer + PyObject_AsWriteBuffer=python36.PyObject_AsWriteBuffer + PyObject_Bytes=python36.PyObject_Bytes + PyObject_Call=python36.PyObject_Call + PyObject_CallFunction=python36.PyObject_CallFunction + PyObject_CallFunctionObjArgs=python36.PyObject_CallFunctionObjArgs + PyObject_CallMethod=python36.PyObject_CallMethod + PyObject_CallMethodObjArgs=python36.PyObject_CallMethodObjArgs + PyObject_CallObject=python36.PyObject_CallObject + PyObject_CheckReadBuffer=python36.PyObject_CheckReadBuffer + PyObject_ClearWeakRefs=python36.PyObject_ClearWeakRefs + PyObject_DelItem=python36.PyObject_DelItem + PyObject_DelItemString=python36.PyObject_DelItemString + PyObject_Dir=python36.PyObject_Dir + PyObject_Format=python36.PyObject_Format + PyObject_Free=python36.PyObject_Free + PyObject_GC_Del=python36.PyObject_GC_Del + PyObject_GC_Track=python36.PyObject_GC_Track + PyObject_GC_UnTrack=python36.PyObject_GC_UnTrack + PyObject_GenericGetAttr=python36.PyObject_GenericGetAttr + PyObject_GenericSetAttr=python36.PyObject_GenericSetAttr + PyObject_GetAttr=python36.PyObject_GetAttr + PyObject_GetAttrString=python36.PyObject_GetAttrString + PyObject_GetItem=python36.PyObject_GetItem + PyObject_GetIter=python36.PyObject_GetIter + PyObject_HasAttr=python36.PyObject_HasAttr + PyObject_HasAttrString=python36.PyObject_HasAttrString + PyObject_Hash=python36.PyObject_Hash + PyObject_HashNotImplemented=python36.PyObject_HashNotImplemented + PyObject_Init=python36.PyObject_Init + PyObject_InitVar=python36.PyObject_InitVar + PyObject_IsInstance=python36.PyObject_IsInstance + PyObject_IsSubclass=python36.PyObject_IsSubclass + PyObject_IsTrue=python36.PyObject_IsTrue + PyObject_Length=python36.PyObject_Length + PyObject_Malloc=python36.PyObject_Malloc + PyObject_Not=python36.PyObject_Not + PyObject_Realloc=python36.PyObject_Realloc + PyObject_Repr=python36.PyObject_Repr + PyObject_RichCompare=python36.PyObject_RichCompare + PyObject_RichCompareBool=python36.PyObject_RichCompareBool + PyObject_SelfIter=python36.PyObject_SelfIter + PyObject_SetAttr=python36.PyObject_SetAttr + PyObject_SetAttrString=python36.PyObject_SetAttrString + PyObject_SetItem=python36.PyObject_SetItem + PyObject_Size=python36.PyObject_Size + PyObject_Str=python36.PyObject_Str + PyObject_Type=python36.PyObject_Type DATA + PyODict_DelItem=python36.PyODict_DelItem + PyODict_New=python36.PyODict_New + PyODict_SetItem=python36.PyODict_SetItem + PyODict_Type=python36.PyODict_Type DATA + PyODictItems_Type=python36.PyODictItems_Type DATA + PyODictIter_Type=python36.PyODictIter_Type DATA + PyODictKeys_Type=python36.PyODictKeys_Type DATA + PyODictValues_Type=python36.PyODictValues_Type DATA + PyParser_SimpleParseFileFlags=python36.PyParser_SimpleParseFileFlags + PyParser_SimpleParseStringFlags=python36.PyParser_SimpleParseStringFlags + PyProperty_Type=python36.PyProperty_Type DATA + PyRangeIter_Type=python36.PyRangeIter_Type DATA + PyRange_Type=python36.PyRange_Type DATA + PyReversed_Type=python36.PyReversed_Type DATA + PySeqIter_New=python36.PySeqIter_New + PySeqIter_Type=python36.PySeqIter_Type DATA + PySequence_Check=python36.PySequence_Check + PySequence_Concat=python36.PySequence_Concat + PySequence_Contains=python36.PySequence_Contains + PySequence_Count=python36.PySequence_Count + PySequence_DelItem=python36.PySequence_DelItem + PySequence_DelSlice=python36.PySequence_DelSlice + PySequence_Fast=python36.PySequence_Fast + PySequence_GetItem=python36.PySequence_GetItem + PySequence_GetSlice=python36.PySequence_GetSlice + PySequence_In=python36.PySequence_In + PySequence_InPlaceConcat=python36.PySequence_InPlaceConcat + PySequence_InPlaceRepeat=python36.PySequence_InPlaceRepeat + PySequence_Index=python36.PySequence_Index + PySequence_Length=python36.PySequence_Length + PySequence_List=python36.PySequence_List + PySequence_Repeat=python36.PySequence_Repeat + PySequence_SetItem=python36.PySequence_SetItem + PySequence_SetSlice=python36.PySequence_SetSlice + PySequence_Size=python36.PySequence_Size + PySequence_Tuple=python36.PySequence_Tuple + PySetIter_Type=python36.PySetIter_Type DATA + PySet_Add=python36.PySet_Add + PySet_Clear=python36.PySet_Clear + PySet_Contains=python36.PySet_Contains + PySet_Discard=python36.PySet_Discard + PySet_New=python36.PySet_New + PySet_Pop=python36.PySet_Pop + PySet_Size=python36.PySet_Size + PySet_Type=python36.PySet_Type DATA + PySlice_GetIndices=python36.PySlice_GetIndices + PySlice_GetIndicesEx=python36.PySlice_GetIndicesEx + PySlice_New=python36.PySlice_New + PySlice_Type=python36.PySlice_Type DATA + PySortWrapper_Type=python36.PySortWrapper_Type DATA + PyState_FindModule=python36.PyState_FindModule + PyState_AddModule=python36.PyState_AddModule + PyState_RemoveModule=python36.PyState_RemoveModule + PyStructSequence_GetItem=python36.PyStructSequence_GetItem + PyStructSequence_New=python36.PyStructSequence_New + PyStructSequence_NewType=python36.PyStructSequence_NewType + PyStructSequence_SetItem=python36.PyStructSequence_SetItem + PySuper_Type=python36.PySuper_Type DATA + PySys_AddWarnOption=python36.PySys_AddWarnOption + PySys_AddWarnOptionUnicode=python36.PySys_AddWarnOptionUnicode + PySys_FormatStderr=python36.PySys_FormatStderr + PySys_FormatStdout=python36.PySys_FormatStdout + PySys_GetObject=python36.PySys_GetObject + PySys_HasWarnOptions=python36.PySys_HasWarnOptions + PySys_ResetWarnOptions=python36.PySys_ResetWarnOptions + PySys_SetArgv=python36.PySys_SetArgv + PySys_SetArgvEx=python36.PySys_SetArgvEx + PySys_SetObject=python36.PySys_SetObject + PySys_SetPath=python36.PySys_SetPath + PySys_WriteStderr=python36.PySys_WriteStderr + PySys_WriteStdout=python36.PySys_WriteStdout + PyThreadState_Clear=python36.PyThreadState_Clear + PyThreadState_Delete=python36.PyThreadState_Delete + PyThreadState_DeleteCurrent=python36.PyThreadState_DeleteCurrent + PyThreadState_Get=python36.PyThreadState_Get + PyThreadState_GetDict=python36.PyThreadState_GetDict + PyThreadState_New=python36.PyThreadState_New + PyThreadState_SetAsyncExc=python36.PyThreadState_SetAsyncExc + PyThreadState_Swap=python36.PyThreadState_Swap + PyTraceBack_Here=python36.PyTraceBack_Here + PyTraceBack_Print=python36.PyTraceBack_Print + PyTraceBack_Type=python36.PyTraceBack_Type DATA + PyTupleIter_Type=python36.PyTupleIter_Type DATA + PyTuple_ClearFreeList=python36.PyTuple_ClearFreeList + PyTuple_GetItem=python36.PyTuple_GetItem + PyTuple_GetSlice=python36.PyTuple_GetSlice + PyTuple_New=python36.PyTuple_New + PyTuple_Pack=python36.PyTuple_Pack + PyTuple_SetItem=python36.PyTuple_SetItem + PyTuple_Size=python36.PyTuple_Size + PyTuple_Type=python36.PyTuple_Type DATA + PyType_ClearCache=python36.PyType_ClearCache + PyType_FromSpec=python36.PyType_FromSpec + PyType_FromSpecWithBases=python36.PyType_FromSpecWithBases + PyType_GenericAlloc=python36.PyType_GenericAlloc + PyType_GenericNew=python36.PyType_GenericNew + PyType_GetFlags=python36.PyType_GetFlags + PyType_GetSlot=python36.PyType_GetSlot + PyType_IsSubtype=python36.PyType_IsSubtype + PyType_Modified=python36.PyType_Modified + PyType_Ready=python36.PyType_Ready + PyType_Type=python36.PyType_Type DATA + PyUnicodeDecodeError_Create=python36.PyUnicodeDecodeError_Create + PyUnicodeDecodeError_GetEncoding=python36.PyUnicodeDecodeError_GetEncoding + PyUnicodeDecodeError_GetEnd=python36.PyUnicodeDecodeError_GetEnd + PyUnicodeDecodeError_GetObject=python36.PyUnicodeDecodeError_GetObject + PyUnicodeDecodeError_GetReason=python36.PyUnicodeDecodeError_GetReason + PyUnicodeDecodeError_GetStart=python36.PyUnicodeDecodeError_GetStart + PyUnicodeDecodeError_SetEnd=python36.PyUnicodeDecodeError_SetEnd + PyUnicodeDecodeError_SetReason=python36.PyUnicodeDecodeError_SetReason + PyUnicodeDecodeError_SetStart=python36.PyUnicodeDecodeError_SetStart + PyUnicodeEncodeError_GetEncoding=python36.PyUnicodeEncodeError_GetEncoding + PyUnicodeEncodeError_GetEnd=python36.PyUnicodeEncodeError_GetEnd + PyUnicodeEncodeError_GetObject=python36.PyUnicodeEncodeError_GetObject + PyUnicodeEncodeError_GetReason=python36.PyUnicodeEncodeError_GetReason + PyUnicodeEncodeError_GetStart=python36.PyUnicodeEncodeError_GetStart + PyUnicodeEncodeError_SetEnd=python36.PyUnicodeEncodeError_SetEnd + PyUnicodeEncodeError_SetReason=python36.PyUnicodeEncodeError_SetReason + PyUnicodeEncodeError_SetStart=python36.PyUnicodeEncodeError_SetStart + PyUnicodeIter_Type=python36.PyUnicodeIter_Type DATA + PyUnicodeTranslateError_GetEnd=python36.PyUnicodeTranslateError_GetEnd + PyUnicodeTranslateError_GetObject=python36.PyUnicodeTranslateError_GetObject + PyUnicodeTranslateError_GetReason=python36.PyUnicodeTranslateError_GetReason + PyUnicodeTranslateError_GetStart=python36.PyUnicodeTranslateError_GetStart + PyUnicodeTranslateError_SetEnd=python36.PyUnicodeTranslateError_SetEnd + PyUnicodeTranslateError_SetReason=python36.PyUnicodeTranslateError_SetReason + PyUnicodeTranslateError_SetStart=python36.PyUnicodeTranslateError_SetStart + PyUnicode_Append=python36.PyUnicode_Append + PyUnicode_AppendAndDel=python36.PyUnicode_AppendAndDel + PyUnicode_AsASCIIString=python36.PyUnicode_AsASCIIString + PyUnicode_AsCharmapString=python36.PyUnicode_AsCharmapString + PyUnicode_AsDecodedObject=python36.PyUnicode_AsDecodedObject + PyUnicode_AsDecodedUnicode=python36.PyUnicode_AsDecodedUnicode + PyUnicode_AsEncodedObject=python36.PyUnicode_AsEncodedObject + PyUnicode_AsEncodedString=python36.PyUnicode_AsEncodedString + PyUnicode_AsEncodedUnicode=python36.PyUnicode_AsEncodedUnicode + PyUnicode_AsLatin1String=python36.PyUnicode_AsLatin1String + PyUnicode_AsRawUnicodeEscapeString=python36.PyUnicode_AsRawUnicodeEscapeString + PyUnicode_AsUTF16String=python36.PyUnicode_AsUTF16String + PyUnicode_AsUTF32String=python36.PyUnicode_AsUTF32String + PyUnicode_AsUTF8String=python36.PyUnicode_AsUTF8String + PyUnicode_AsUnicodeEscapeString=python36.PyUnicode_AsUnicodeEscapeString + PyUnicode_AsWideChar=python36.PyUnicode_AsWideChar + PyUnicode_ClearFreelist=python36.PyUnicode_ClearFreelist + PyUnicode_Compare=python36.PyUnicode_Compare + PyUnicode_Concat=python36.PyUnicode_Concat + PyUnicode_Contains=python36.PyUnicode_Contains + PyUnicode_Count=python36.PyUnicode_Count + PyUnicode_Decode=python36.PyUnicode_Decode + PyUnicode_DecodeASCII=python36.PyUnicode_DecodeASCII + PyUnicode_DecodeCharmap=python36.PyUnicode_DecodeCharmap + PyUnicode_DecodeFSDefault=python36.PyUnicode_DecodeFSDefault + PyUnicode_DecodeFSDefaultAndSize=python36.PyUnicode_DecodeFSDefaultAndSize + PyUnicode_DecodeLatin1=python36.PyUnicode_DecodeLatin1 + PyUnicode_DecodeRawUnicodeEscape=python36.PyUnicode_DecodeRawUnicodeEscape + PyUnicode_DecodeUTF16=python36.PyUnicode_DecodeUTF16 + PyUnicode_DecodeUTF16Stateful=python36.PyUnicode_DecodeUTF16Stateful + PyUnicode_DecodeUTF32=python36.PyUnicode_DecodeUTF32 + PyUnicode_DecodeUTF32Stateful=python36.PyUnicode_DecodeUTF32Stateful + PyUnicode_DecodeUTF8=python36.PyUnicode_DecodeUTF8 + PyUnicode_DecodeUTF8Stateful=python36.PyUnicode_DecodeUTF8Stateful + PyUnicode_DecodeUnicodeEscape=python36.PyUnicode_DecodeUnicodeEscape + PyUnicode_FSConverter=python36.PyUnicode_FSConverter + PyUnicode_FSDecoder=python36.PyUnicode_FSDecoder + PyUnicode_Find=python36.PyUnicode_Find + PyUnicode_Format=python36.PyUnicode_Format + PyUnicode_FromEncodedObject=python36.PyUnicode_FromEncodedObject + PyUnicode_FromFormat=python36.PyUnicode_FromFormat + PyUnicode_FromFormatV=python36.PyUnicode_FromFormatV + PyUnicode_FromObject=python36.PyUnicode_FromObject + PyUnicode_FromOrdinal=python36.PyUnicode_FromOrdinal + PyUnicode_FromString=python36.PyUnicode_FromString + PyUnicode_FromStringAndSize=python36.PyUnicode_FromStringAndSize + PyUnicode_FromWideChar=python36.PyUnicode_FromWideChar + PyUnicode_GetDefaultEncoding=python36.PyUnicode_GetDefaultEncoding + PyUnicode_GetSize=python36.PyUnicode_GetSize + PyUnicode_IsIdentifier=python36.PyUnicode_IsIdentifier + PyUnicode_Join=python36.PyUnicode_Join + PyUnicode_Partition=python36.PyUnicode_Partition + PyUnicode_RPartition=python36.PyUnicode_RPartition + PyUnicode_RSplit=python36.PyUnicode_RSplit + PyUnicode_Replace=python36.PyUnicode_Replace + PyUnicode_Resize=python36.PyUnicode_Resize + PyUnicode_RichCompare=python36.PyUnicode_RichCompare + PyUnicode_SetDefaultEncoding=python36.PyUnicode_SetDefaultEncoding + PyUnicode_Split=python36.PyUnicode_Split + PyUnicode_Splitlines=python36.PyUnicode_Splitlines + PyUnicode_Tailmatch=python36.PyUnicode_Tailmatch + PyUnicode_Translate=python36.PyUnicode_Translate + PyUnicode_BuildEncodingMap=python36.PyUnicode_BuildEncodingMap + PyUnicode_CompareWithASCIIString=python36.PyUnicode_CompareWithASCIIString + PyUnicode_DecodeUTF7=python36.PyUnicode_DecodeUTF7 + PyUnicode_DecodeUTF7Stateful=python36.PyUnicode_DecodeUTF7Stateful + PyUnicode_EncodeFSDefault=python36.PyUnicode_EncodeFSDefault + PyUnicode_InternFromString=python36.PyUnicode_InternFromString + PyUnicode_InternImmortal=python36.PyUnicode_InternImmortal + PyUnicode_InternInPlace=python36.PyUnicode_InternInPlace + PyUnicode_Type=python36.PyUnicode_Type DATA + PyWeakref_GetObject=python36.PyWeakref_GetObject DATA + PyWeakref_NewProxy=python36.PyWeakref_NewProxy + PyWeakref_NewRef=python36.PyWeakref_NewRef + PyWrapperDescr_Type=python36.PyWrapperDescr_Type DATA + PyWrapper_New=python36.PyWrapper_New + PyZip_Type=python36.PyZip_Type DATA + Py_AddPendingCall=python36.Py_AddPendingCall + Py_AtExit=python36.Py_AtExit + Py_BuildValue=python36.Py_BuildValue + Py_CompileString=python36.Py_CompileString + Py_DecRef=python36.Py_DecRef + Py_EndInterpreter=python36.Py_EndInterpreter + Py_Exit=python36.Py_Exit + Py_FatalError=python36.Py_FatalError + Py_FileSystemDefaultEncoding=python36.Py_FileSystemDefaultEncoding DATA + Py_Finalize=python36.Py_Finalize + Py_GetBuildInfo=python36.Py_GetBuildInfo + Py_GetCompiler=python36.Py_GetCompiler + Py_GetCopyright=python36.Py_GetCopyright + Py_GetExecPrefix=python36.Py_GetExecPrefix + Py_GetPath=python36.Py_GetPath + Py_GetPlatform=python36.Py_GetPlatform + Py_GetPrefix=python36.Py_GetPrefix + Py_GetProgramFullPath=python36.Py_GetProgramFullPath + Py_GetProgramName=python36.Py_GetProgramName + Py_GetPythonHome=python36.Py_GetPythonHome + Py_GetRecursionLimit=python36.Py_GetRecursionLimit + Py_GetVersion=python36.Py_GetVersion + Py_HasFileSystemDefaultEncoding=python36.Py_HasFileSystemDefaultEncoding DATA + Py_IncRef=python36.Py_IncRef + Py_Initialize=python36.Py_Initialize + Py_InitializeEx=python36.Py_InitializeEx + Py_IsInitialized=python36.Py_IsInitialized + Py_Main=python36.Py_Main + Py_MakePendingCalls=python36.Py_MakePendingCalls + Py_NewInterpreter=python36.Py_NewInterpreter + Py_ReprEnter=python36.Py_ReprEnter + Py_ReprLeave=python36.Py_ReprLeave + Py_SetProgramName=python36.Py_SetProgramName + Py_SetPythonHome=python36.Py_SetPythonHome + Py_SetRecursionLimit=python36.Py_SetRecursionLimit + Py_SymtableString=python36.Py_SymtableString + Py_VaBuildValue=python36.Py_VaBuildValue + _PyErr_BadInternalCall=python36._PyErr_BadInternalCall + _PyObject_CallFunction_SizeT=python36._PyObject_CallFunction_SizeT + _PyObject_CallMethod_SizeT=python36._PyObject_CallMethod_SizeT + _PyObject_GC_Malloc=python36._PyObject_GC_Malloc + _PyObject_GC_New=python36._PyObject_GC_New + _PyObject_GC_NewVar=python36._PyObject_GC_NewVar + _PyObject_GC_Resize=python36._PyObject_GC_Resize + _PyObject_New=python36._PyObject_New + _PyObject_NewVar=python36._PyObject_NewVar + _PyState_AddModule=python36._PyState_AddModule + _PyThreadState_Init=python36._PyThreadState_Init + _PyThreadState_Prealloc=python36._PyThreadState_Prealloc + _PyTrash_delete_later=python36._PyTrash_delete_later DATA + _PyTrash_delete_nesting=python36._PyTrash_delete_nesting DATA + _PyTrash_deposit_object=python36._PyTrash_deposit_object + _PyTrash_destroy_chain=python36._PyTrash_destroy_chain + _PyWeakref_CallableProxyType=python36._PyWeakref_CallableProxyType DATA + _PyWeakref_ProxyType=python36._PyWeakref_ProxyType DATA + _PyWeakref_RefType=python36._PyWeakref_RefType DATA + _Py_BuildValue_SizeT=python36._Py_BuildValue_SizeT + _Py_CheckRecursionLimit=python36._Py_CheckRecursionLimit DATA + _Py_CheckRecursiveCall=python36._Py_CheckRecursiveCall + _Py_Dealloc=python36._Py_Dealloc + _Py_EllipsisObject=python36._Py_EllipsisObject DATA + _Py_FalseStruct=python36._Py_FalseStruct DATA + _Py_NoneStruct=python36._Py_NoneStruct DATA + _Py_NotImplementedStruct=python36._Py_NotImplementedStruct DATA + _Py_SwappedOp=python36._Py_SwappedOp DATA + _Py_TrueStruct=python36._Py_TrueStruct DATA + _Py_VaBuildValue_SizeT=python36._Py_VaBuildValue_SizeT + _PyArg_Parse_SizeT=python36._PyArg_Parse_SizeT + _PyArg_ParseTuple_SizeT=python36._PyArg_ParseTuple_SizeT + _PyArg_ParseTupleAndKeywords_SizeT=python36._PyArg_ParseTupleAndKeywords_SizeT + _PyArg_VaParse_SizeT=python36._PyArg_VaParse_SizeT + _PyArg_VaParseTupleAndKeywords_SizeT=python36._PyArg_VaParseTupleAndKeywords_SizeT + _Py_BuildValue_SizeT=python36._Py_BuildValue_SizeT diff --git a/PCbuild/prepare_ssl.bat b/PCbuild/prepare_ssl.bat index c08a9f3..3153615 100644 --- a/PCbuild/prepare_ssl.bat +++ b/PCbuild/prepare_ssl.bat @@ -3,10 +3,10 @@ if not defined HOST_PYTHON ( if %1 EQU Debug (
shift
set HOST_PYTHON=python_d.exe
- if not exist python35_d.dll exit 1
+ if not exist python36_d.dll exit 1
) ELSE (
set HOST_PYTHON=python.exe
- if not exist python35.dll exit 1
+ if not exist python36.dll exit 1
)
)
%HOST_PYTHON% prepare_ssl.py %1
diff --git a/PCbuild/xxlimited.vcxproj b/PCbuild/xxlimited.vcxproj index 0144fa9..9dbdc77 100644 --- a/PCbuild/xxlimited.vcxproj +++ b/PCbuild/xxlimited.vcxproj @@ -62,7 +62,7 @@ </PropertyGroup> <ItemDefinitionGroup> <ClCompile> - <PreprocessorDefinitions>%(PreprocessorDefinitions);Py_LIMITED_API=0x03050000</PreprocessorDefinitions> + <PreprocessorDefinitions>%(PreprocessorDefinitions);Py_LIMITED_API=0x03060000</PreprocessorDefinitions> </ClCompile> <Link> <AdditionalDependencies>wsock32.lib;%(AdditionalDependencies)</AdditionalDependencies> diff --git a/Python/compile.c b/Python/compile.c index 2202e8f..ce2b8d6 100644 --- a/Python/compile.c +++ b/Python/compile.c @@ -3628,9 +3628,9 @@ expr_constant(struct compiler *c, expr_ty e) BLOCK finally: if an exception was raised: - exc = copy of (exception, instance, traceback) + exc = copy of (exception, instance, traceback) else: - exc = (None, None, None) + exc = (None, None, None) if not (await exit(*exc)): raise */ @@ -1,5 +1,5 @@ -This is Python version 3.5.0 beta 2 -=================================== +This is Python version 3.6.0 alpha 1 +==================================== Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015 Python Software Foundation. All rights reserved. @@ -50,9 +50,9 @@ What's New ---------- We try to have a comprehensive overview of the changes in the "What's New in -Python 3.5" document, found at +Python 3.6" document, found at - http://docs.python.org/3.5/whatsnew/3.5.html + http://docs.python.org/3.6/whatsnew/3.6.html For a more detailed change log, read Misc/NEWS (though this file, too, is incomplete, and also doesn't list anything merged in from the 2.7 release under @@ -65,9 +65,9 @@ entitled "Installing multiple versions". Documentation ------------- -Documentation for Python 3.5 is online, updated daily: +Documentation for Python 3.6 is online, updated daily: - http://docs.python.org/3.5/ + http://docs.python.org/3.6/ It can also be downloaded in many formats for faster access. The documentation is downloadable in HTML, PDF, and reStructuredText formats; the latter version @@ -92,7 +92,7 @@ backported versions of certain key Python 3.x features. A source-to-source translation tool, "2to3", can take care of the mundane task of converting large amounts of source code. It is not a complete solution but is complemented by the deprecation warnings in 2.6. See -http://docs.python.org/3.5/library/2to3.html for more information. +http://docs.python.org/3.6/library/2to3.html for more information. Testing @@ -130,7 +130,7 @@ same prefix you must decide which version (if any) is your "primary" version. Install that version using "make install". Install all other versions using "make altinstall". -For example, if you want to install Python 2.6, 2.7 and 3.5 with 2.7 being the +For example, if you want to install Python 2.6, 2.7 and 3.6 with 2.7 being the primary version, you would execute "make install" in your 2.7 build directory and "make altinstall" in the others. diff --git a/Tools/buildbot/build-amd64.bat b/Tools/buildbot/build-amd64.bat deleted file mode 100644 index f77407b..0000000 --- a/Tools/buildbot/build-amd64.bat +++ /dev/null @@ -1,5 +0,0 @@ -@rem Formerly used by the buildbot "compile" step.
-@echo This script is no longer used and may be removed in the future.
-@echo To get the same effect as this script, use
-@echo PCbuild\build.bat -d -e -k -p x64
-call "%~dp0build.bat" -p x64 %*
diff --git a/Tools/buildbot/clean-amd64.bat b/Tools/buildbot/clean-amd64.bat deleted file mode 100644 index b53c7c1..0000000 --- a/Tools/buildbot/clean-amd64.bat +++ /dev/null @@ -1,5 +0,0 @@ -@rem Formerly used by the buildbot "clean" step.
-@echo This script is no longer used and may be removed in the future.
-@echo To get the same effect as this script, use `clean.bat` from this
-@echo directory and pass `-p x64` as two arguments.
-call "%~dp0clean.bat" -p x64 %*
diff --git a/Tools/buildbot/external-amd64.bat b/Tools/buildbot/external-amd64.bat deleted file mode 100644 index bfaef05..0000000 --- a/Tools/buildbot/external-amd64.bat +++ /dev/null @@ -1,3 +0,0 @@ -@echo This script is no longer used and may be removed in the future.
-@echo Please use PCbuild\get_externals.bat instead.
-@"%~dp0..\..\PCbuild\get_externals.bat" %*
diff --git a/Tools/buildbot/external.bat b/Tools/buildbot/external.bat deleted file mode 100644 index bfaef05..0000000 --- a/Tools/buildbot/external.bat +++ /dev/null @@ -1,3 +0,0 @@ -@echo This script is no longer used and may be removed in the future.
-@echo Please use PCbuild\get_externals.bat instead.
-@"%~dp0..\..\PCbuild\get_externals.bat" %*
diff --git a/Tools/buildbot/test-amd64.bat b/Tools/buildbot/test-amd64.bat deleted file mode 100644 index e48329c..0000000 --- a/Tools/buildbot/test-amd64.bat +++ /dev/null @@ -1,6 +0,0 @@ -@rem Formerly used by the buildbot "test" step.
-@echo This script is no longer used and may be removed in the future.
-@echo To get the same effect as this script, use
-@echo PCbuild\rt.bat -q -d -x64 -uall -rwW
-@echo or use `test.bat` in this directory and pass `-x64` as an argument.
-call "%~dp0test.bat" -x64 %*
@@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.69 for python 3.5. +# Generated by GNU Autoconf 2.69 for python 3.6. # # Report bugs to <http://bugs.python.org/>. # @@ -580,8 +580,8 @@ MAKEFLAGS= # Identity of this package. PACKAGE_NAME='python' PACKAGE_TARNAME='python' -PACKAGE_VERSION='3.5' -PACKAGE_STRING='python 3.5' +PACKAGE_VERSION='3.6' +PACKAGE_STRING='python 3.6' PACKAGE_BUGREPORT='http://bugs.python.org/' PACKAGE_URL='' @@ -1378,7 +1378,7 @@ if test "$ac_init_help" = "long"; then # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures python 3.5 to adapt to many kinds of systems. +\`configure' configures python 3.6 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1443,7 +1443,7 @@ fi if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of python 3.5:";; + short | recursive ) echo "Configuration of python 3.6:";; esac cat <<\_ACEOF @@ -1597,7 +1597,7 @@ fi test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -python configure 3.5 +python configure 3.6 generated by GNU Autoconf 2.69 Copyright (C) 2012 Free Software Foundation, Inc. @@ -2436,7 +2436,7 @@ cat >config.log <<_ACEOF This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by python $as_me 3.5, which was +It was created by python $as_me 3.6, which was generated by GNU Autoconf 2.69. Invocation command line was $ $0 $@ @@ -3009,7 +3009,7 @@ rm confdefs.h mv confdefs.h.new confdefs.h -VERSION=3.5 +VERSION=3.6 # Version number of Python's own shared library file. @@ -16543,7 +16543,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1 # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by python $as_me 3.5, which was +This file was extended by python $as_me 3.6, which was generated by GNU Autoconf 2.69. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -16605,7 +16605,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`" ac_cs_version="\\ -python config.status 3.5 +python config.status 3.6 configured by $0, generated by GNU Autoconf 2.69, with options \\"\$ac_cs_config\\" diff --git a/configure.ac b/configure.ac index 56a73df..668234d 100644 --- a/configure.ac +++ b/configure.ac @@ -3,7 +3,7 @@ dnl * Please run autoreconf to test your changes! * dnl *********************************************** # Set VERSION so we only need to edit in one place (i.e., here) -m4_define(PYTHON_VERSION, 3.5) +m4_define(PYTHON_VERSION, 3.6) AC_PREREQ(2.65) |