Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Merge 3.4.0a3 release changes.

This commit is contained in:
Larry Hastings 2013-09-30 01:13:32 +01:00
parent e9cbd181a2 5d23e6d543
commit d92af0f1d9
26 changed files with 84 additions and 986 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Doc/library/ssl.rst
View File

@ -659,7 +659,8 @@ SSL sockets also have the following additional methods and attributes:
.. method:: SSLSocket.getpeercert(binary_form=False)
If there is no certificate for the peer on the other end of the connection,
returns ``None``.
return ``None``. If the SSL handshake hasn't been done yet, raise
:exc:`ValueError`.
If the ``binary_form`` parameter is :const:`False`, and a certificate was
received from the peer, this method returns a :class:`dict` instance. If the
@ -716,6 +717,9 @@ SSL sockets also have the following additional methods and attributes:
The returned dictionary includes additional items such as ``issuer``
and ``notBefore``.
.. versionchanged:: 3.4
:exc:`ValueError` is raised when the handshake isn't done.
.. method:: SSLSocket.cipher()
Returns a three-value tuple containing the name of the cipher being used, the

7
Lib/distutils/command/build_ext.py
View File

@ -242,11 +242,10 @@ class build_ext(Command):
# building python standard extensions
self.library_dirs.append('.')
# for extensions under Linux or Solaris with a shared Python library,
# For building extensions with a shared Python library,
# Python's library directory must be appended to library_dirs
sysconfig.get_config_var('Py_ENABLE_SHARED')
if (sys.platform.startswith(('linux', 'gnu', 'sunos'))
and sysconfig.get_config_var('Py_ENABLE_SHARED')):
# See Issues: #1600860, #4366
if (sysconfig.get_config_var('Py_ENABLE_SHARED')):
if sys.executable.startswith(os.path.join(sys.exec_prefix, "bin")):
# building third party extensions
self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))

25
Lib/distutils/tests/test_cmd.py
View File

@ -34,6 +34,18 @@ class CommandTestCase(unittest.TestCase):
self.assertRaises(DistutilsOptionError,
cmd.ensure_string_list, 'not_string_list2')
cmd.option1 = 'ok,dok'
cmd.ensure_string_list('option1')
self.assertEqual(cmd.option1, ['ok', 'dok'])
cmd.option2 = ['xxx', 'www']
cmd.ensure_string_list('option2')
cmd.option3 = ['ok', 2]
self.assertRaises(DistutilsOptionError, cmd.ensure_string_list,
'option3')
def test_make_file(self):
cmd = self.cmd
@ -77,19 +89,6 @@ class CommandTestCase(unittest.TestCase):
cmd.option3 = 1
self.assertRaises(DistutilsOptionError, cmd.ensure_string, 'option3')
def test_ensure_string_list(self):
cmd = self.cmd
cmd.option1 = 'ok,dok'
cmd.ensure_string_list('option1')
self.assertEqual(cmd.option1, ['ok', 'dok'])
cmd.option2 = ['xxx', 'www']
cmd.ensure_string_list('option2')
cmd.option3 = ['ok', 2]
self.assertRaises(DistutilsOptionError, cmd.ensure_string_list,
'option3')
def test_ensure_filename(self):
cmd = self.cmd
cmd.option1 = __file__

19
Lib/site.py
View File

@ -405,12 +405,19 @@ def enablerlcompleter():
# want to ignore the exception.
pass
history = os.path.join(os.path.expanduser('~'), '.python_history')
try:
readline.read_history_file(history)
except IOError:
pass
atexit.register(readline.write_history_file, history)
if readline.get_history_item(1) is None:
# If no history was loaded, default to .python_history.
# The guard is necessary to avoid doubling history size at
# each interpreter exit when readline was already configured
# through a PYTHONSTARTUP hook, see:
# http://bugs.python.org/issue5845#msg198636
history = os.path.join(os.path.expanduser('~'),
'.python_history')
try:
readline.read_history_file(history)
except IOError:
pass
atexit.register(readline.write_history_file, history)
sys.__interactivehook__ = register_readline

8
Lib/test/_test_multiprocessing.py
View File

@ -3038,15 +3038,15 @@ class TestInitializers(unittest.TestCase):
# Verifies os.close(sys.stdin.fileno) vs. sys.stdin.close() behavior
#
def _ThisSubProcess(q):
def _this_sub_process(q):
try:
item = q.get(block=False)
except pyqueue.Empty:
pass
def _TestProcess(q):
def _test_process(q):
queue = multiprocessing.Queue()
subProc = multiprocessing.Process(target=_ThisSubProcess, args=(queue,))
subProc = multiprocessing.Process(target=_this_sub_process, args=(queue,))
subProc.daemon = True
subProc.start()
subProc.join()
@ -3085,7 +3085,7 @@ class TestStdinBadfiledescriptor(unittest.TestCase):
def test_queue_in_process(self):
queue = multiprocessing.Queue()
proc = multiprocessing.Process(target=_TestProcess, args=(queue,))
proc = multiprocessing.Process(target=_test_process, args=(queue,))
proc.start()
proc.join()

1
Lib/test/test_complex.py
View File

@ -101,7 +101,6 @@ class ComplexTest(unittest.TestCase):
# FIXME: The following currently crashes on Alpha
# self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
def test_truediv(self):
self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)

4
Lib/test/test_dis.py
View File

@ -247,7 +247,6 @@ class DisTests(unittest.TestCase):
expected = _BIG_LINENO_FORMAT % (i + 2)
self.do_disassembly_test(func(i), expected)
def test_big_linenos(self):
from test import dis_module
self.do_disassembly_test(dis_module, dis_module_expected_results)
@ -273,9 +272,6 @@ class DisTests(unittest.TestCase):
pass
self.assertRaises(RuntimeError, dis.dis, None)
def test_dis_object(self):
self.assertRaises(TypeError, dis.dis, object())
def test_dis_traceback(self):
try:
del sys.last_traceback

4
Lib/test/test_ftplib.py
View File

@ -534,10 +534,6 @@ class TestFTPClass(TestCase):
dir = self.client.cwd('/foo')
self.assertEqual(dir, '250 cwd ok')
def test_mkd(self):
dir = self.client.mkd('/foo')
self.assertEqual(dir, '/foo')
def test_pwd(self):
dir = self.client.pwd()
self.assertEqual(dir, 'pwd ok')

11
Lib/test/test_import.py
View File

@ -252,17 +252,6 @@ class ImportTests(unittest.TestCase):
if TESTFN in sys.modules:
del sys.modules[TESTFN]
def test_import_name_binding(self):
# import x.y.z binds x in the current namespace.
import test as x
import test.support
self.assertIs(x, test, x.__name__)
self.assertTrue(hasattr(test.support, "__file__"))
# import x.y.z as w binds z as w.
import test.support as y
self.assertIs(y, test.support, y.__name__)
def test_import_by_filename(self):
path = os.path.abspath(TESTFN)
encoding = sys.getfilesystemencoding()

12
Lib/test/test_regrtest.py
View File

@ -167,19 +167,13 @@ class ParseArgsTestCase(unittest.TestCase):
self.assertEqual(ns.testdir, os.path.join(support.SAVEDCWD, 'foo'))
self.checkError(['--testdir'], 'expected one argument')
def test_findleaks(self):
for opt in '-l', '--findleaks':
with self.subTest(opt=opt):
ns = regrtest._parse_args([opt])
self.assertTrue(ns.findleaks)
def test_findleaks(self):
def test_runleaks(self):
for opt in '-L', '--runleaks':
with self.subTest(opt=opt):
ns = regrtest._parse_args([opt])
self.assertTrue(ns.runleaks)
def test_findleaks(self):
def test_huntrleaks(self):
for opt in '-R', '--huntrleaks':
with self.subTest(opt=opt):
ns = regrtest._parse_args([opt, ':'])
@ -207,7 +201,7 @@ class ParseArgsTestCase(unittest.TestCase):
self.checkError([opt, '2', '-l'], "don't go together")
self.checkError([opt, '2', '-M', '4G'], "don't go together")
def test_findleaks(self):
def test_coverage(self):
for opt in '-T', '--coverage':
with self.subTest(opt=opt):
ns = regrtest._parse_args([opt])

6
Lib/test/test_smtplib.py
View File

@ -239,14 +239,14 @@ class DebuggingServerTests(unittest.TestCase):
self.assertEqual(smtp.rset(), expected)
smtp.quit()
def testNotImplemented(self):
def testELHO(self):
# EHLO isn't implemented in DebuggingServer
smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost', timeout=3)
expected = (502, b'Error: command "EHLO" not implemented')
expected = (250, b'\nSIZE 33554432\nHELP')
self.assertEqual(smtp.ehlo(), expected)
smtp.quit()
def testNotImplemented(self):
def testEXPNNotImplemented(self):
# EXPN isn't implemented in DebuggingServer
smtp = smtplib.SMTP(HOST, self.port, local_hostname='localhost', timeout=3)
expected = (502, b'EXPN not implemented')

8
Lib/test/test_ssl.py
View File

@ -1588,8 +1588,14 @@ else:
context.load_cert_chain(CERTFILE)
server = ThreadedEchoServer(context=context, chatty=False)
with server:
s = context.wrap_socket(socket.socket())
s = context.wrap_socket(socket.socket(),
do_handshake_on_connect=False)
s.connect((HOST, server.port))
# getpeercert() raise ValueError while the handshake isn't
# done.
with self.assertRaises(ValueError):
s.getpeercert()
s.do_handshake()
cert = s.getpeercert()
self.assertTrue(cert, "Can't get peer certificate.")
cipher = s.cipher()

2
Lib/test/test_webbrowser.py
View File

@ -158,7 +158,7 @@ class OperaCommandTest(CommandTestMixin, unittest.TestCase):
options=['-remote'],
arguments=['openURL({},new-window)'.format(URL)])
def test_open_new(self):
def test_open_new_tab(self):
self._test('open_new_tab',
options=['-remote'],
arguments=['openURL({},new-page)'.format(URL)])

7
Lib/venv/__init__.py
View File

@ -25,18 +25,11 @@ optional arguments:
--upgrade Upgrade the environment directory to use this version
of Python, assuming Python has been upgraded in-place.
"""
import base64
import io
import logging
import os
import os.path
import shutil
import sys
import sysconfig
try:
import threading
except ImportError:
threading = None
import types
logger = logging.getLogger(__name__)

3
Lib/xml/dom/minidom.py
View File

@ -370,9 +370,6 @@ class Attr(Node):
except AttributeError:
return self.nodeName.split(":", 1)[-1]
def _get_name(self):
return self.name
def _get_specified(self):
return self.specified

110
Mac/Tools/Doc/HelpIndexingTool/Help_Indexing_Tool_Suite.py
View File

@ -1,110 +0,0 @@
"""Suite Help Indexing Tool Suite: Special events that just the Help Indexing Tool supports.
Level 0, version 0
Generated from /Developer/Applications/Apple Help Indexing Tool.app
AETE/AEUT resource version 1/1, language 0, script 0
"""
import aetools
import MacOS
_code = 'HIT '
class Help_Indexing_Tool_Suite_Events:
def turn_anchor_indexing(self, _object, _attributes={}, **_arguments):
"""turn anchor indexing: Turns anchor indexing on or off.
Required argument: \xd2on\xd3 or \xd2off\xd3, to turn anchor indexing on or off
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'HIT '
_subcode = 'tAnc'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_turn_remote_root = {
'with_root_url' : 'rURL',
}
def turn_remote_root(self, _object, _attributes={}, **_arguments):
"""turn remote root: Turn usage of remote root for content on the web on or off. If turning \xd2on\xd3, supply a string as second parameter.
Required argument: \xd2on\xd3 or \xd2off\xd3, to turn remote root on or off
Keyword argument with_root_url: The remote root to use, in the form of \xd2http://www.apple.com/help/\xd3.
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'HIT '
_subcode = 'tRem'
aetools.keysubst(_arguments, self._argmap_turn_remote_root)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def use_tokenizer(self, _object, _attributes={}, **_arguments):
"""use tokenizer: Tells the indexing tool which tokenizer to use.
Required argument: Specify \xd2English\xd3, \xd2European\xd3, \xd2Japanese\xd3, \xd2Korean\xd3, or \xd2Simple\xd3.
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'HIT '
_subcode = 'uTok'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
class application(aetools.ComponentItem):
"""application - Application class """
want = 'capp'
class _Prop_idleStatus(aetools.NProperty):
"""idleStatus - """
which = 'sIdl'
want = 'bool'
application._superclassnames = []
application._privpropdict = {
'idleStatus' : _Prop_idleStatus,
}
application._privelemdict = {
}
#
# Indices of types declared in this module
#
_classdeclarations = {
'capp' : application,
}
_propdeclarations = {
'sIdl' : _Prop_idleStatus,
}
_compdeclarations = {
}
_enumdeclarations = {
}

49
Mac/Tools/Doc/HelpIndexingTool/Miscellaneous_Standards.py
View File

@ -1,49 +0,0 @@
"""Suite Miscellaneous Standards: Useful events that aren\xd5t in any other suite
Level 0, version 0
Generated from /Developer/Applications/Apple Help Indexing Tool.app
AETE/AEUT resource version 1/1, language 0, script 0
"""
import aetools
import MacOS
_code = 'misc'
class Miscellaneous_Standards_Events:
def revert(self, _object, _attributes={}, **_arguments):
"""revert: Revert an object to the most recently saved version
Required argument: object to revert
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'misc'
_subcode = 'rvrt'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
#
# Indices of types declared in this module
#
_classdeclarations = {
}
_propdeclarations = {
}
_compdeclarations = {
}
_enumdeclarations = {
}

32
Mac/Tools/Doc/HelpIndexingTool/Required_Suite.py
View File

@ -1,32 +0,0 @@
"""Suite Required Suite: Terms that every application should support
Level 1, version 1
Generated from /Developer/Applications/Apple Help Indexing Tool.app
AETE/AEUT resource version 1/1, language 0, script 0
"""
import aetools
import MacOS
_code = 'reqd'
from StdSuites.Required_Suite import *
class Required_Suite_Events(Required_Suite_Events):
pass
#
# Indices of types declared in this module
#
_classdeclarations = {
}
_propdeclarations = {
}
_compdeclarations = {
}
_enumdeclarations = {
}

343
Mac/Tools/Doc/HelpIndexingTool/Standard_Suite.py
View File

@ -1,343 +0,0 @@
"""Suite Standard Suite: Common terms for most applications
Level 1, version 1
Generated from /Developer/Applications/Apple Help Indexing Tool.app
AETE/AEUT resource version 1/1, language 0, script 0
"""
import aetools
import MacOS
_code = 'CoRe'
from StdSuites.Standard_Suite import *
class Standard_Suite_Events(Standard_Suite_Events):
_argmap_close = {
'saving' : 'savo',
'in_' : 'kfil',
}
def close(self, _object, _attributes={}, **_arguments):
"""close: Close an object
Required argument: the objects to close
Keyword argument saving: specifies whether or not changes should be saved before closing
Keyword argument in_: the file in which to save the object
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'clos'
aetools.keysubst(_arguments, self._argmap_close)
_arguments['----'] = _object
aetools.enumsubst(_arguments, 'savo', _Enum_savo)
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def data_size(self, _object, _attributes={}, **_arguments):
"""data size: Return the size in bytes of an object
Required argument: the object whose data size is to be returned
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: the size of the object in bytes
"""
_code = 'core'
_subcode = 'dsiz'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def get(self, _object, _attributes={}, **_arguments):
"""get: Get the data for an object
Required argument: the object whose data is to be returned
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: The data from the object
"""
_code = 'core'
_subcode = 'getd'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_make = {
'new' : 'kocl',
'at' : 'insh',
'with_data' : 'data',
'with_properties' : 'prdt',
}
def make(self, _no_object=None, _attributes={}, **_arguments):
"""make: Make a new element
Keyword argument new: the class of the new element
Keyword argument at: the location at which to insert the element
Keyword argument with_data: the initial data for the element
Keyword argument with_properties: the initial values for the properties of the element
Keyword argument _attributes: AppleEvent attribute dictionary
Returns: Object specifier for the new element
"""
_code = 'core'
_subcode = 'crel'
aetools.keysubst(_arguments, self._argmap_make)
if _no_object is not None: raise TypeError('No direct arg expected')
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def open(self, _object, _attributes={}, **_arguments):
"""open: Open the specified object(s)
Required argument: Objects to open. Can be a list of files or an object specifier.
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'aevt'
_subcode = 'odoc'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
def print_(self, _object, _attributes={}, **_arguments):
"""print: Print the specified object(s)
Required argument: Objects to print. Can be a list of files or an object specifier.
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'aevt'
_subcode = 'pdoc'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_save = {
'in_' : 'kfil',
'as' : 'fltp',
}
def save(self, _object, _attributes={}, **_arguments):
"""save: save a set of objects
Required argument: Objects to save.
Keyword argument in_: the file in which to save the object(s)
Keyword argument as: the file type of the document in which to save the data
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'save'
aetools.keysubst(_arguments, self._argmap_save)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
_argmap_set = {
'to' : 'data',
}
def set(self, _object, _attributes={}, **_arguments):
"""set: Set an object\xd5s data
Required argument: the object to change
Keyword argument to: the new value
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'core'
_subcode = 'setd'
aetools.keysubst(_arguments, self._argmap_set)
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
class application(aetools.ComponentItem):
"""application - An application program """
want = 'capp'
# element 'cwin' as ['indx', 'name', 'rele']
# element 'docu' as ['name']
class window(aetools.ComponentItem):
"""window - A Window """
want = 'cwin'
class _Prop_bounds(aetools.NProperty):
"""bounds - the boundary rectangle for the window """
which = 'pbnd'
want = 'qdrt'
class _Prop_closeable(aetools.NProperty):
"""closeable - Does the window have a close box? """
which = 'hclb'
want = 'bool'
class _Prop_floating(aetools.NProperty):
"""floating - Does the window float? """
which = 'isfl'
want = 'bool'
class _Prop_index(aetools.NProperty):
"""index - the number of the window """
which = 'pidx'
want = 'long'
class _Prop_modal(aetools.NProperty):
"""modal - Is the window modal? """
which = 'pmod'
want = 'bool'
class _Prop_name(aetools.NProperty):
"""name - the title of the window """
which = 'pnam'
want = 'itxt'
class _Prop_position(aetools.NProperty):
"""position - upper left coordinates of window """
which = 'ppos'
want = 'QDpt'
class _Prop_resizable(aetools.NProperty):
"""resizable - Is the window resizable? """
which = 'prsz'
want = 'bool'
class _Prop_titled(aetools.NProperty):
"""titled - Does the window have a title bar? """
which = 'ptit'
want = 'bool'
class _Prop_visible(aetools.NProperty):
"""visible - is the window visible? """
which = 'pvis'
want = 'bool'
class _Prop_zoomable(aetools.NProperty):
"""zoomable - Is the window zoomable? """
which = 'iszm'
want = 'bool'
class _Prop_zoomed(aetools.NProperty):
"""zoomed - Is the window zoomed? """
which = 'pzum'
want = 'bool'
class document(aetools.ComponentItem):
"""document - A Document """
want = 'docu'
class _Prop_modified(aetools.NProperty):
"""modified - Has the document been modified since the last save? """
which = 'imod'
want = 'bool'
application._superclassnames = []
application._privpropdict = {
}
application._privelemdict = {
'document' : document,
'window' : window,
}
window._superclassnames = []
window._privpropdict = {
'bounds' : _Prop_bounds,
'closeable' : _Prop_closeable,
'floating' : _Prop_floating,
'index' : _Prop_index,
'modal' : _Prop_modal,
'name' : _Prop_name,
'position' : _Prop_position,
'resizable' : _Prop_resizable,
'titled' : _Prop_titled,
'visible' : _Prop_visible,
'zoomable' : _Prop_zoomable,
'zoomed' : _Prop_zoomed,
}
window._privelemdict = {
}
document._superclassnames = []
document._privpropdict = {
'modified' : _Prop_modified,
'name' : _Prop_name,
}
document._privelemdict = {
}
_Enum_savo = {
'yes' : 'yes ', # Save objects now
'no' : 'no ', # Do not save objects
'ask' : 'ask ', # Ask the user whether to save
}
#
# Indices of types declared in this module
#
_classdeclarations = {
'capp' : application,
'cwin' : window,
'docu' : document,
}
_propdeclarations = {
'hclb' : _Prop_closeable,
'imod' : _Prop_modified,
'isfl' : _Prop_floating,
'iszm' : _Prop_zoomable,
'pbnd' : _Prop_bounds,
'pidx' : _Prop_index,
'pmod' : _Prop_modal,
'pnam' : _Prop_name,
'ppos' : _Prop_position,
'prsz' : _Prop_resizable,
'ptit' : _Prop_titled,
'pvis' : _Prop_visible,
'pzum' : _Prop_zoomed,
}
_compdeclarations = {
}
_enumdeclarations = {
'savo' : _Enum_savo,
}

78
Mac/Tools/Doc/HelpIndexingTool/__init__.py
View File

@ -1,78 +0,0 @@
"""
Package generated from /Developer/Applications/Apple Help Indexing Tool.app
"""
import aetools
Error = aetools.Error
import Standard_Suite
import Help_Indexing_Tool_Suite
import odds_and_ends
import Miscellaneous_Standards
import Required_Suite
_code_to_module = {
'CoRe' : Standard_Suite,
'HIT ' : Help_Indexing_Tool_Suite,
'Odds' : odds_and_ends,
'misc' : Miscellaneous_Standards,
'reqd' : Required_Suite,
}
_code_to_fullname = {
'CoRe' : ('HelpIndexingTool.Standard_Suite', 'Standard_Suite'),
'HIT ' : ('HelpIndexingTool.Help_Indexing_Tool_Suite', 'Help_Indexing_Tool_Suite'),
'Odds' : ('HelpIndexingTool.odds_and_ends', 'odds_and_ends'),
'misc' : ('HelpIndexingTool.Miscellaneous_Standards', 'Miscellaneous_Standards'),
'reqd' : ('HelpIndexingTool.Required_Suite', 'Required_Suite'),
}
from Standard_Suite import *
from Help_Indexing_Tool_Suite import *
from odds_and_ends import *
from Miscellaneous_Standards import *
from Required_Suite import *
def getbaseclasses(v):
if not getattr(v, '_propdict', None):
v._propdict = {}
v._elemdict = {}
for superclassname in getattr(v, '_superclassnames', []):
superclass = eval(superclassname)
getbaseclasses(superclass)
v._propdict.update(getattr(superclass, '_propdict', {}))
v._elemdict.update(getattr(superclass, '_elemdict', {}))
v._propdict.update(getattr(v, '_privpropdict', {}))
v._elemdict.update(getattr(v, '_privelemdict', {}))
import StdSuites
#
# Set property and element dictionaries now that all classes have been defined
#
getbaseclasses(window)
getbaseclasses(application)
getbaseclasses(document)
getbaseclasses(application)
#
# Indices of types declared in this module
#
_classdeclarations = {
'cwin' : window,
'capp' : application,
'docu' : document,
'capp' : application,
}
class HelpIndexingTool(Standard_Suite_Events,
Help_Indexing_Tool_Suite_Events,
odds_and_ends_Events,
Miscellaneous_Standards_Events,
Required_Suite_Events,
aetools.TalkTo):
_signature = 'hiti'
_moduleName = 'HelpIndexingTool'

49
Mac/Tools/Doc/HelpIndexingTool/odds_and_ends.py
View File

@ -1,49 +0,0 @@
"""Suite odds and ends: Things that should be in some standard suite, but aren\xd5t
Level 1, version 1
Generated from /Developer/Applications/Apple Help Indexing Tool.app
AETE/AEUT resource version 1/1, language 0, script 0
"""
import aetools
import MacOS
_code = 'Odds'
class odds_and_ends_Events:
def select(self, _object=None, _attributes={}, **_arguments):
"""select: Select the specified object
Required argument: the object to select
Keyword argument _attributes: AppleEvent attribute dictionary
"""
_code = 'misc'
_subcode = 'slct'
if _arguments: raise TypeError('No optional args expected')
_arguments['----'] = _object
_reply, _arguments, _attributes = self.send(_code, _subcode,
_arguments, _attributes)
if _arguments.get('errn', 0):
raise aetools.Error(aetools.decodeerror(_arguments))
# XXXX Optionally decode result
if _arguments.has_key('----'):
return _arguments['----']
#
# Indices of types declared in this module
#
_classdeclarations = {
}
_propdeclarations = {
}
_compdeclarations = {
}
_enumdeclarations = {
}

35
Mac/Tools/Doc/README
View File

@ -1,35 +0,0 @@
In this directory you can build the Python documentation in a form that
is suitable for access with Apple Help Viewer. This will enable the
"Python Documentation" menu entries in the MacPython IDE Help menu.
Unfortunately the procedure to build the docs is not very streamlined.
First, edit setup.py. At the top, edit MAJOR_VERSION and MINOR_VERSION,
and check that DESTDIR makes sense. The documentation will be installed
inside PythonIDE.app.
In DocBuild.initialize_options, set self.download to True if you want to
download the docs. Set it to False if you want to build the docs from
the source tree, but this requires LaTex and lots of other stuff.
Doable, but not easy.
Second, if you want to download the docs you may need to do a couple
more edits. The way the docs are packaged will often change between
major releases. Fiddle DocBuild.downloadDocs to make it do the right
thing (download the docs from python.org, unpack them, rename the
directory to "build/html").
After these edits you should be ready to roll. "pythonw setup.py build"
should download and unpack (or build) the docs. Next, it will do some
magic to make the docs indexable. Finally, it will run the Apple Help
Indexing Tool. (This last step is the reason you must use "pythonw" as
opposed to "python"). Usually it will time out while waiting for AHIT to
do its work. Wait until AHIT is done.
Now you're ready to install with "python setup.py install".
After this is done test your work. Fire up PythonIDE, and check that
Help->Python Documentation brings up the documentation in the Help Viewer.
Also open an IDE edit window, type something like "import sys", select
"import", and use Help->Lookup in Python Documentation to check that the
index has been generated correctly.

213
Mac/Tools/Doc/setup.py
View File

@ -1,213 +0,0 @@
# Build and install an Apple Help Viewer compatible version of the Python
# documentation into the framework.
# Code by Bill Fancher, with some modifications by Jack Jansen.
#
# You must run this as a two-step process
# 1. python setupDocs.py build
# 2. Wait for Apple Help Indexing Tool to finish
# 3. python setupDocs.py install
#
# To do:
# - test whether the docs are available locally before downloading
# - fix buildDocsFromSource
# - Get documentation version from sys.version, fallback to 2.2.1
# - See if we can somehow detect that Apple Help Indexing Tool is finished
# - data_files to setup() doesn't seem the right way to pass the arguments
#
import sys, os, re
from distutils.cmd import Command
from distutils.command.build import build
from distutils.core import setup
from distutils.file_util import copy_file
from distutils.dir_util import copy_tree
from distutils.log import log
from distutils.spawn import spawn
from distutils import sysconfig, dep_util
from distutils.util import change_root
import HelpIndexingTool
import Carbon.File
import time
MAJOR_VERSION='2.4'
MINOR_VERSION='2.4.1'
DESTDIR='/Applications/MacPython-%s/PythonIDE.app/Contents/Resources/English.lproj/PythonDocumentation' % MAJOR_VERSION
class DocBuild(build):
def initialize_options(self):
build.initialize_options(self)
self.build_html = None
self.build_dest = None
self.download = 1
self.doc_version = MINOR_VERSION # Only needed if download is true
def finalize_options(self):
build.finalize_options(self)
if self.build_html is None:
self.build_html = os.path.join(self.build_base, 'html')
if self.build_dest is None:
self.build_dest = os.path.join(self.build_base, 'PythonDocumentation')
def spawn(self, *args):
spawn(args, 1, self.verbose, self.dry_run)
def downloadDocs(self):
workdir = os.getcwd()
# XXX Note: the next strings may change from version to version
url = 'http://www.python.org/ftp/python/doc/%s/html-%s.tar.bz2' % \
(self.doc_version,self.doc_version)
tarfile = 'html-%s.tar.bz2' % self.doc_version
dirname = 'Python-Docs-%s' % self.doc_version
if os.path.exists(self.build_html):
raise RuntimeError('%s: already exists, please remove and try again' % self.build_html)
os.chdir(self.build_base)
self.spawn('curl','-O', url)
self.spawn('tar', '-xjf', tarfile)
os.rename(dirname, 'html')
os.chdir(workdir)
## print "** Please unpack %s" % os.path.join(self.build_base, tarfile)
## print "** Unpack the files into %s" % self.build_html
## raise RuntimeError, "You need to unpack the docs manually"
def buildDocsFromSource(self):
srcdir = '../../..'
docdir = os.path.join(srcdir, 'Doc')
htmldir = os.path.join(docdir, 'html')
spawn(('make','--directory', docdir, 'html'), 1, self.verbose, self.dry_run)
self.mkpath(self.build_html)
copy_tree(htmldir, self.build_html)
def ensureHtml(self):
if not os.path.exists(self.build_html):
if self.download:
self.downloadDocs()
else:
self.buildDocsFromSource()
def hackIndex(self):
ind_html = 'index.html'
#print 'self.build_dest =', self.build_dest
hackedIndex = file(os.path.join(self.build_dest, ind_html),'w')
origIndex = file(os.path.join(self.build_html,ind_html))
r = re.compile('<style type="text/css">.*</style>', re.DOTALL)
hackedIndex.write(r.sub('<META NAME="AppleTitle" CONTENT="Python Documentation">',origIndex.read()))
def hackFile(self,d,f):
origPath = os.path.join(d,f)
assert(origPath[:len(self.build_html)] == self.build_html)
outPath = os.path.join(self.build_dest, d[len(self.build_html)+1:], f)
(name, ext) = os.path.splitext(f)
if os.path.isdir(origPath):
self.mkpath(outPath)
elif ext == '.html':
if self.verbose: print('hacking %s to %s' % (origPath,outPath))
hackedFile = file(outPath, 'w')
origFile = file(origPath,'r')
hackedFile.write(self.r.sub('<dl><dt><dd>', origFile.read()))
else:
copy_file(origPath, outPath)
def hackHtml(self):
self.r = re.compile('<dl><dd>')
os.walk(self.build_html, self.visit, None)
def visit(self, dummy, dirname, filenames):
for f in filenames:
self.hackFile(dirname, f)
def makeHelpIndex(self):
app = '/Developer/Applications/Apple Help Indexing Tool.app'
self.spawn('open', '-a', app , self.build_dest)
print("Please wait until Apple Help Indexing Tool finishes before installing")
def makeHelpIndex(self):
app = HelpIndexingTool.HelpIndexingTool(start=1)
app.open(Carbon.File.FSSpec(self.build_dest))
sys.stderr.write("Waiting for Help Indexing Tool to start...")
while 1:
# This is bad design in the suite generation code!
idle = app._get(HelpIndexingTool.Help_Indexing_Tool_Suite._Prop_idleStatus())
time.sleep(10)
if not idle: break
sys.stderr.write(".")
sys.stderr.write("\n")
sys.stderr.write("Waiting for Help Indexing Tool to finish...")
while 1:
# This is bad design in the suite generation code!
idle = app._get(HelpIndexingTool.Help_Indexing_Tool_Suite._Prop_idleStatus())
time.sleep(10)
if idle: break
sys.stderr.write(".")
sys.stderr.write("\n")
def run(self):
self.ensure_finalized()
self.mkpath(self.build_base)
self.ensureHtml()
if not os.path.isdir(self.build_html):
raise RuntimeError("Can't find source folder for documentation.")
self.mkpath(self.build_dest)
if dep_util.newer(os.path.join(self.build_html,'index.html'), os.path.join(self.build_dest,'index.html')):
self.mkpath(self.build_dest)
self.hackHtml()
self.hackIndex()
self.makeHelpIndex()
class AHVDocInstall(Command):
description = "install Apple Help Viewer html files"
user_options = [('install-doc=', 'd',
'directory to install HTML tree'),
('root=', None,
"install everything relative to this alternate root directory"),
]
def initialize_options(self):
self.build_dest = None
self.install_doc = None
self.prefix = None
self.root = None
def finalize_options(self):
self.set_undefined_options('install',
('prefix', 'prefix'),
('root', 'root'))
# import pdb ; pdb.set_trace()
build_cmd = self.get_finalized_command('build')
if self.build_dest is None:
build_cmd = self.get_finalized_command('build')
self.build_dest = build_cmd.build_dest
if self.install_doc is None:
self.install_doc = os.path.join(self.prefix, DESTDIR)
print('INSTALL', self.build_dest, '->', self.install_doc)
def run(self):
self.finalize_options()
self.ensure_finalized()
print("Running Installer")
instloc = self.install_doc
if self.root:
instloc = change_root(self.root, instloc)
self.mkpath(instloc)
copy_tree(self.build_dest, instloc)
print("Installation complete")
def mungeVersion(infile, outfile):
i = file(infile,'r')
o = file(outfile,'w')
o.write(re.sub('\$\(VERSION\)',sysconfig.get_config_var('VERSION'),i.read()))
i.close()
o.close()
def main():
# turn off warnings when deprecated modules are imported
## import warnings
## warnings.filterwarnings("ignore",category=DeprecationWarning)
setup(name = 'Documentation',
version = '%d.%d' % sys.version_info[:2],
cmdclass = {'install_data':AHVDocInstall, 'build':DocBuild},
data_files = ['dummy'],
)
if __name__ == '__main__':
main()

17
Misc/NEWS
View File

@ -13,6 +13,23 @@ Core and Builtins
Library
-------
- Issue #5845: In site.py, only load readline history from ~/.python_history
if no history has been read already. This avoids double writes to the
history file at shutdown.
- Properly initialize all fields of a SSL object after allocation.
- Issue #19095: SSLSocket.getpeercert() now raises ValueError when the
SSL handshake hasn't been done.
- Issue #4366: Fix building extensions on all platforms when --enable-shared
is used.
Build
-----
- Issue #19130: Correct PCbuild/readme.txt, Python 3.3 and 3.4 require VS 2010.
What's New in Python 3.4.0 Alpha 3?
===================================

11
Modules/_ssl.c
View File

@ -220,7 +220,8 @@ typedef struct {
SSL *ssl;
PySSLContext *ctx; /* weakref to SSL context */
X509 *peer_cert;
int shutdown_seen_zero;
char shutdown_seen_zero;
char handshake_done;
enum py_ssl_server_or_client socket_type;
} PySSLSocket;
@ -485,6 +486,8 @@ newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
self->ssl = NULL;
self->Socket = NULL;
self->ctx = sslctx;
self->shutdown_seen_zero = 0;
self->handshake_done = 0;
Py_INCREF(sslctx);
/* Make sure the SSL error state is initialized */
@ -590,6 +593,7 @@ static PyObject *PySSL_SSLdo_handshake(PySSLSocket *self)
PySSL_BEGIN_ALLOW_THREADS
self->peer_cert = SSL_get_peer_certificate(self->ssl);
PySSL_END_ALLOW_THREADS
self->handshake_done = 1;
Py_INCREF(Py_None);
return Py_None;
@ -1153,6 +1157,11 @@ PySSL_peercert(PySSLSocket *self, PyObject *args)
if (!PyArg_ParseTuple(args, "|p:peer_certificate", &binary_mode))
return NULL;
if (!self->handshake_done) {
PyErr_SetString(PyExc_ValueError,
"handshake not done yet");
return NULL;
}
if (!self->peer_cert)
Py_RETURN_NONE;

10
PCbuild/readme.txt
View File

@ -1,13 +1,13 @@
Building Python using VC++ 10.0
------------------------------
-------------------------------
This directory is used to build Python for Win32 and x64 platforms, e.g.
Windows 2000, XP, Vista and Windows Server 2008. In order to build 32-bit
debug and release executables, Microsoft Visual C++ 2008 Express Edition is
debug and release executables, Microsoft Visual C++ 2010 Express Edition is
required at the very least. In order to build 64-bit debug and release
executables, Visual Studio 2008 Standard Edition is required at the very
executables, Visual Studio 2010 Standard Edition is required at the very
least. In order to build all of the above, as well as generate release builds
that make use of Profile Guided Optimisation (PG0), Visual Studio 2008
that make use of Profile Guided Optimisation (PG0), Visual Studio 2010
Professional Edition is required at the very least. The official Python
releases are built with this version of Visual Studio.
@ -57,6 +57,8 @@ PC/VS7.1/
Visual Studio 2003 (7.1)
PC/VS8.0/
Visual Studio 2005 (8.0)
PC/VS9.0/
Visual Studio 2008 (9.0)
C RUNTIME