Add __future__.py to std library, + dull test to verify that assignments

therein are of the proper form.

Lib/__future__.py

+"""__future__:  Record of phased-in incompatible language changes.
+
+Each line is of the form:
+
+    FeatureName = ReleaseInfo
+
+ReleaseInfo is a pair of the form:
+
+    (OptionalRelease, MandatoryRelease)
+
+where, normally, OptionalRelease < MandatoryRelease, and both are 5-tuples
+of the same form as sys.version_info:
+
+    (PY_MAJOR_VERSION, # the 2 in 2.1.0a3; an int
+     PY_MINOR_VERSION, # the 1; an int
+     PY_MICRO_VERSION, # the 0; an int
+     PY_RELEASE_LEVEL, # "alpha", "beta", "candidate" or "final"; string
+     PY_RELEASE_SERIAL # the 3; an int
+    )
+
+OptionalRelease records the first release in which
+
+    from __future__ import FeatureName
+
+was accepted.
+
+In the case of MandatoryReleases that have not yet occurred, 
+MandatoryRelease predicts the release in which the feature will become part 
+of the language.
+
+Else MandatoryRelease records when the feature became part of the language; 
+in releases at or after that, modules no longer need
+
+    from __future__ import FeatureName
+
+to use the feature in question, but may continue to use such imports.
+
+MandatoryRelease may also be None, meaning that a planned feature got 
+dropped.
+
+No line is ever to be deleted from this file.
+"""
+
+nested_scopes = (2, 1, 0, "beta", 1), (2, 2, 0, "final", 0)

Lib/test/output/test___future__

+test___future__

Lib/test/test___future__.py

+#! /usr/bin/env python
+from test_support import verbose, verify
+from types import TupleType, StringType, IntType
+import __future__
+
+GOOD_SERIALS = ("alpha", "beta", "candidate", "final")
+
+features = [x for x in dir(__future__) if x[:1] != "_"]
+for feature in features:
+    value = getattr(__future__, feature)
+    if verbose:
+        print "Checking __future__ ", feature, "value", value
+    verify(type(value) is TupleType, "feature value isn't tuple")
+    verify(len(value) == 2, "feature value isn't 2-tuple")
+
+    optional, mandatory = value
+
+    verify(type(optional) is TupleType, "optional isn't tuple")
+    verify(len(optional) == 5, "optional isn't 5-tuple")
+    major, minor, micro, level, serial = optional
+    verify(type(major) is IntType, "optional major isn't int")
+    verify(type(minor) is IntType, "optional minor isn't int")
+    verify(type(micro) is IntType, "optional micro isn't int")
+    verify(type(level) is StringType, "optional level isn't string")
+    verify(level in GOOD_SERIALS,
+           "optional level string has unknown value")
+    verify(type(serial) is IntType, "optional serial isn't int")
+
+    verify(type(mandatory) is TupleType or
+           mandatory is None, "mandatory isn't tuple or None")
+    if mandatory is not None:
+        verify(len(mandatory) == 5, "mandatory isn't 5-tuple")
+        major, minor, micro, level, serial = mandatory
+        verify(type(major) is IntType, "mandatory major isn't int")
+        verify(type(minor) is IntType, "mandatory minor isn't int")
+        verify(type(micro) is IntType, "mandatory micro isn't int")
+        verify(type(level) is StringType, "mandatory level isn't string")
+        verify(level in GOOD_SERIALS,
+               "mandatory serial string has unknown value")
+        verify(type(serial) is IntType, "mandatory serial isn't int")
+        verify(optional < mandatory,
+               "optional not less than mandatory, and mandatory not None")