expunge the xmlcore changes:

  41667, 41668 - initial switch to xmlcore
  47044        - mention of xmlcore in What's New
  50687        - mention of xmlcore in the library reference

re-apply xmlcore changes to xml:
  41674        - line ending changes (re-applied manually), directory props
  41677        - add cElementTree wrapper
  41678        - PSF licensing for etree
  41812        - whitespace normalization
  42724        - fix svn:eol-style settings
  43681, 43682 - remove Python version-compatibility cruft from minidom
  46773        - fix encoding of \r\n\t in attr values in saxutils
  47269        - added XMLParser alias for cElementTree compatibility

additional tests were added in Lib/test/test_sax.py that failed with
the xmlcore changes; these relate to SF bugs #1511497, #1513611

Doc/lib/markup.tex

@@ -15,17 +15,6 @@ You may still want to be aware of the \ulink{PyXML add-on
 package}{http://pyxml.sourceforge.net/}; that package provides an
 extended set of XML libraries for Python.
 
-Python 2.5 introduces the \module{xmlcore} package; this package
-provides the implementation of the \module{xml} package as distributed
-with the standard library.  The \module{xml} package, as in earlier
-versions, provides an interface that will provide the PyXML
-implementation of the interfaces when available, and the standard
-library implementation if not.  Applications that can use either the
-PyXML implementation or the standard library's implementation may
-continue to make imports from the \module{xml} package; applications
-that want to only import the standard library's implementation can now
-use the \module{xmlcore} package.
-
 The documentation for the \module{xml.dom} and \module{xml.sax}
 packages are the definition of the Python bindings for the DOM and SAX
 interfaces.

Doc/whatsnew/whatsnew25.tex

@@ -1760,13 +1760,6 @@ Konqueror, and elinks.  (Contributed by Oleg Broytmann and Georg
 Brandl.)
 % Patch #754022
 
-\item The standard library's XML-related package
-has been renamed to \module{xmlcore}.  The \module{xml} module will
-now import either the \module{xmlcore} or PyXML version of subpackages
-such as \module{xml.dom}.  The renaming means it will always be
-possible to import the standard library's XML support whether or not
-the PyXML package is installed.
-
 \item The \module{xmlrpclib} module now supports returning 
       \class{datetime} objects for the XML-RPC date type.  Supply 
       \code{use_datetime=True} to the \function{loads()} function
@@ -2404,10 +2397,6 @@ to allow only \code{'/'} and \code{'/RPC2'}.  Setting
 \member{rpc_paths} to \code{None} or an empty tuple disables 
 this path checking.
 
-\item Library: the \module{xml} package has been renamed to \module{xmlcore}.
-The PyXML package will therefore be \module{xml}, and the Python
-distribution's code will always be accessible as \module{xmlcore}.
-
 \item C API: Many functions now use \ctype{Py_ssize_t} 
 instead of \ctype{int} to allow processing more data on 64-bit
 machines.  Extension code may need to make the same change to avoid

Lib/test/test_sax.py

 # regression test for SAX 2.0            -*- coding: iso-8859-1 -*-
 # $Id$
 
-from xmlcore.sax import make_parser, ContentHandler, \
-     SAXException, SAXReaderNotAvailable, SAXParseException
+from xml.sax import make_parser, ContentHandler, \
+                    SAXException, SAXReaderNotAvailable, SAXParseException
 try:
     make_parser()
 except SAXReaderNotAvailable:
     # don't try to test this module if we cannot create a parser
     raise ImportError("no XML parsers available")
-from xmlcore.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
-     XMLFilterBase
-from xmlcore.sax.expatreader import create_parser
-from xmlcore.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
+from xml.sax.saxutils import XMLGenerator, escape, unescape, quoteattr, \
+                             XMLFilterBase
+from xml.sax.expatreader import create_parser
+from xml.sax.xmlreader import InputSource, AttributesImpl, AttributesNSImpl
 from cStringIO import StringIO
 from test.test_support import verify, verbose, TestFailed, findfile
 import os
@@ -36,17 +36,17 @@ def test_make_parser2():
         # Creating parsers several times in a row should succeed.
         # Testing this because there have been failures of this kind
         # before.
-        from xmlcore.sax import make_parser
+        from xml.sax import make_parser
         p = make_parser()
-        from xmlcore.sax import make_parser
+        from xml.sax import make_parser
         p = make_parser()
-        from xmlcore.sax import make_parser
+        from xml.sax import make_parser
         p = make_parser()
-        from xmlcore.sax import make_parser
+        from xml.sax import make_parser
         p = make_parser()
-        from xmlcore.sax import make_parser
+        from xml.sax import make_parser
         p = make_parser()
-        from xmlcore.sax import make_parser
+        from xml.sax import make_parser
         p = make_parser()
     except:
         return 0
@@ -108,7 +108,7 @@ def test_make_parser():
     try:
         # Creating a parser should succeed - it should fall back
         # to the expatreader
-        p = make_parser(['xmlcore.parsers.no_such_parser'])
+        p = make_parser(['xml.parsers.no_such_parser'])
     except:
         return 0
     else:
@@ -671,6 +671,55 @@ def test_nsattrs_wattr():
            attrs.getQNameByName((ns_uri, "attr")) == "ns:attr"
 
 
+# During the development of Python 2.5, an attempt to move the "xml"
+# package implementation to a new package ("xmlcore") proved painful.
+# The goal of this change was to allow applications to be able to
+# obtain and rely on behavior in the standard library implementation
+# of the XML support without needing to be concerned about the
+# availability of the PyXML implementation.
+#
+# While the existing import hackery in Lib/xml/__init__.py can cause
+# PyXML's _xmlpus package to supplant the "xml" package, that only
+# works because either implementation uses the "xml" package name for
+# imports.
+#
+# The move resulted in a number of problems related to the fact that
+# the import machinery's "package context" is based on the name that's
+# being imported rather than the __name__ of the actual package
+# containment; it wasn't possible for the "xml" package to be replaced
+# by a simple module that indirected imports to the "xmlcore" package.
+#
+# The following two tests exercised bugs that were introduced in that
+# attempt.  Keeping these tests around will help detect problems with
+# other attempts to provide reliable access to the standard library's
+# implementation of the XML support.
+
+def test_sf_1511497():
+    # Bug report: http://www.python.org/sf/1511497
+    import sys
+    old_modules = sys.modules.copy()
+    for modname in sys.modules.keys():
+        if modname.startswith("xml."):
+            del sys.modules[modname]
+    try:
+        import xml.sax.expatreader
+        module = xml.sax.expatreader
+        return module.__name__ == "xml.sax.expatreader"
+    finally:
+        sys.modules.update(old_modules)
+
+def test_sf_1513611():
+    # Bug report: http://www.python.org/sf/1513611
+    sio = StringIO("invalid")
+    parser = make_parser()
+    from xml.sax import SAXParseException
+    try:
+        parser.parse(sio)
+    except SAXParseException:
+        return True
+    else:
+        return False
+
 # ===== Main program
 
 def make_test_output():

Lib/test/test_xml_etree.py

-# xmlcore.etree test.  This file contains enough tests to make sure that
+# xml.etree test.  This file contains enough tests to make sure that
 # all included components work as they should.  For a more extensive
 # test suite, see the selftest script in the ElementTree distribution.
 
@@ -6,8 +6,6 @@ import doctest, sys
 
 from test import test_support
 
-from xmlcore.etree import ElementTree as ET
-
 SAMPLE_XML = """
 <body>
   <tag>text</tag>
@@ -32,9 +30,9 @@ def sanity():
     """
     Import sanity.
 
-    >>> from xmlcore.etree import ElementTree
-    >>> from xmlcore.etree import ElementInclude
-    >>> from xmlcore.etree import ElementPath
+    >>> from xml.etree import ElementTree
+    >>> from xml.etree import ElementInclude
+    >>> from xml.etree import ElementPath
     """
 
 def check_method(method):
@@ -61,6 +59,8 @@ def interface():
     """
     Test element tree interface.
 
+    >>> from xml.etree import ElementTree as ET
+
     >>> element = ET.Element("tag", key="value")
     >>> tree = ET.ElementTree(element)
 
@@ -108,6 +108,8 @@ def find():
     """
     Test find methods (including xpath syntax).
 
+    >>> from xml.etree import ElementTree as ET
+
     >>> elem = ET.XML(SAMPLE_XML)
     >>> elem.find("tag").tag
     'tag'
@@ -174,6 +176,8 @@ def find():
 def parseliteral():
     r"""
 
+    >>> from xml.etree import ElementTree as ET
+
     >>> element = ET.XML("<html><body>text</body></html>")
     >>> ET.ElementTree(element).write(sys.stdout)
     <html><body>text</body></html>
@@ -195,19 +199,6 @@ def parseliteral():
     'body'
     """
 
-def check_encoding(encoding):
-    """
-    >>> check_encoding("ascii")
-    >>> check_encoding("us-ascii")
-    >>> check_encoding("iso-8859-1")
-    >>> check_encoding("iso-8859-15")
-    >>> check_encoding("cp437")
-    >>> check_encoding("mac-roman")
-    """
-    ET.XML(
-        "<?xml version='1.0' encoding='%s'?><xml />" % encoding
-        )
-
 #
 # xinclude tests (samples from appendix C of the xinclude specification)
 
@@ -282,14 +273,16 @@ def xinclude_loader(href, parse="xml", encoding=None):
     except KeyError:
         raise IOError("resource not found")
     if parse == "xml":
-        return ET.XML(data)
+        from xml.etree.ElementTree import XML
+        return XML(data)
     return data
 
 def xinclude():
     r"""
     Basic inclusion example (XInclude C.1)
 
-    >>> from xmlcore.etree import ElementInclude
+    >>> from xml.etree import ElementTree as ET
+    >>> from xml.etree import ElementInclude
 
     >>> document = xinclude_loader("C1.xml")
     >>> ElementInclude.include(document, xinclude_loader)

Lib/test/test_xml_etree_c.py

-# xmlcore.etree test for cElementTree
+# xml.etree test for cElementTree
 
 import doctest, sys
 
 from test import test_support
 
-from xmlcore.etree import cElementTree as ET
+from xml.etree import cElementTree as ET
 
 SAMPLE_XML = """
 <body>
@@ -30,7 +30,7 @@ def sanity():
     """
     Import sanity.
 
-    >>> from xmlcore.etree import cElementTree
+    >>> from xml.etree import cElementTree
     """
 
 def check_method(method):

Lib/xml.py → Lib/xml/__init__.py

@@ -16,8 +16,6 @@ etree -- The ElementTree XML library.  This is a subset of the full
 
 """
 
-import sys
-import xmlcore
 
 __all__ = ["dom", "parsers", "sax", "etree"]
 
@@ -29,10 +27,11 @@ __version__ = "$Revision$".split()[-2:][0]
 
 _MINIMUM_XMLPLUS_VERSION = (0, 8, 4)
 
+
 try:
     import _xmlplus
 except ImportError:
-    sys.modules[__name__] = xmlcore
+    pass
 else:
     try:
         v = _xmlplus.version_info
@@ -41,7 +40,8 @@ else:
         pass
     else:
         if v >= _MINIMUM_XMLPLUS_VERSION:
-            _xmlplus.__path__.extend(xmlcore.__path__)
+            import sys
+            _xmlplus.__path__.extend(__path__)
             sys.modules[__name__] = _xmlplus
         else:
             del v

Lib/xmlcore/dom/domreg.py → Lib/xml/dom/domreg.py

@@ -2,7 +2,7 @@
 directly. Instead, the functions getDOMImplementation and
 registerDOMImplementation should be imported from xml.dom."""
 
-from xmlcore.dom.minicompat import *  # isinstance, StringTypes
+from xml.dom.minicompat import *  # isinstance, StringTypes
 
 # This is a list of well-known implementations.  Well-known names
 # should be published by posting to xml-sig@python.org, and are

Lib/xmlcore/dom/expatbuilder.py → Lib/xml/dom/expatbuilder.py

@@ -27,13 +27,13 @@ This avoids all the overhead of SAX and pulldom to gain performance.
 #      calling any methods on the node object if it exists.  (A rather
 #      nice speedup is achieved this way as well!)
 
-from xmlcore.dom import xmlbuilder, minidom, Node
-from xmlcore.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE
-from xmlcore.parsers import expat
-from xmlcore.dom.minidom import _append_child, _set_attribute_node
-from xmlcore.dom.NodeFilter import NodeFilter
+from xml.dom import xmlbuilder, minidom, Node
+from xml.dom import EMPTY_NAMESPACE, EMPTY_PREFIX, XMLNS_NAMESPACE
+from xml.parsers import expat
+from xml.dom.minidom import _append_child, _set_attribute_node
+from xml.dom.NodeFilter import NodeFilter
 
-from xmlcore.dom.minicompat import *
+from xml.dom.minicompat import *
 
 TEXT_NODE = Node.TEXT_NODE
 CDATA_SECTION_NODE = Node.CDATA_SECTION_NODE

Lib/xmlcore/dom/minicompat.py → Lib/xml/dom/minicompat.py

@@ -38,7 +38,7 @@
 
 __all__ = ["NodeList", "EmptyNodeList", "StringTypes", "defproperty"]
 
-import xmlcore.dom
+import xml.dom
 
 try:
     unicode
@@ -71,6 +71,7 @@ class NodeList(list):
     def __setstate__(self, state):
         self[:] = state
 
+
 class EmptyNodeList(tuple):
     __slots__ = ()
 

Lib/xmlcore/dom/pulldom.py → Lib/xml/dom/pulldom.py

-import xmlcore.sax
-import xmlcore.sax.handler
+import xml.sax
+import xml.sax.handler
 import types
 
 try:
@@ -16,12 +16,12 @@ PROCESSING_INSTRUCTION = "PROCESSING_INSTRUCTION"
 IGNORABLE_WHITESPACE = "IGNORABLE_WHITESPACE"
 CHARACTERS = "CHARACTERS"
 
-class PullDOM(xmlcore.sax.ContentHandler):
+class PullDOM(xml.sax.ContentHandler):
     _locator = None
     document = None
 
     def __init__(self, documentFactory=None):
-        from xmlcore.dom import XML_NAMESPACE
+        from xml.dom import XML_NAMESPACE
         self.documentFactory = documentFactory
         self.firstEvent = [None, None]
         self.lastEvent = self.firstEvent
@@ -164,8 +164,8 @@ class PullDOM(xmlcore.sax.ContentHandler):
 
     def startDocument(self):
         if self.documentFactory is None:
-            import xmlcore.dom.minidom
-            self.documentFactory = xmlcore.dom.minidom.Document.implementation
+            import xml.dom.minidom
+            self.documentFactory = xml.dom.minidom.Document.implementation
 
     def buildDocument(self, uri, tagname):
         # Can't do that in startDocument, since we need the tagname
@@ -219,7 +219,7 @@ class DOMEventStream:
     def reset(self):
         self.pulldom = PullDOM()
         # This content handler relies on namespace support
-        self.parser.setFeature(xmlcore.sax.handler.feature_namespaces, 1)
+        self.parser.setFeature(xml.sax.handler.feature_namespaces, 1)
         self.parser.setContentHandler(self.pulldom)
 
     def __getitem__(self, pos):
@@ -335,7 +335,7 @@ def parse(stream_or_string, parser=None, bufsize=None):
     else:
         stream = stream_or_string
     if not parser:
-        parser = xmlcore.sax.make_parser()
+        parser = xml.sax.make_parser()
     return DOMEventStream(stream, parser, bufsize)
 
 def parseString(string, parser=None):
@@ -347,5 +347,5 @@ def parseString(string, parser=None):
     bufsize = len(string)
     buf = StringIO(string)
     if not parser:
-        parser = xmlcore.sax.make_parser()
+        parser = xml.sax.make_parser()
     return DOMEventStream(buf, parser, bufsize)

Lib/xmlcore/dom/xmlbuilder.py → Lib/xml/dom/xmlbuilder.py

 """Implementation of the DOM Level 3 'LS-Load' feature."""
 
 import copy
-import xmlcore.dom
+import xml.dom
 
-from xmlcore.dom.NodeFilter import NodeFilter
+from xml.dom.NodeFilter import NodeFilter
 
 
 __all__ = ["DOMBuilder", "DOMEntityResolver", "DOMInputSource"]
@@ -78,13 +78,13 @@ class DOMBuilder:
             try:
                 settings = self._settings[(_name_xform(name), state)]
             except KeyError:
-                raise xmlcore.dom.NotSupportedErr(
+                raise xml.dom.NotSupportedErr(
                     "unsupported feature: %r" % (name,))
             else:
                 for name, value in settings:
                     setattr(self._options, name, value)
         else:
-            raise xmlcore.dom.NotFoundErr("unknown feature: " + repr(name))
+            raise xml.dom.NotFoundErr("unknown feature: " + repr(name))
 
     def supportsFeature(self, name):
         return hasattr(self._options, _name_xform(name))
@@ -175,7 +175,7 @@ class DOMBuilder:
                                  or options.create_entity_ref_nodes
                                  or options.entities
                                  or options.cdata_sections))
-            raise xmlcore.dom.NotFoundErr("feature %s not known" % repr(name))
+            raise xml.dom.NotFoundErr("feature %s not known" % repr(name))
 
     def parseURI(self, uri):
         if self.entityResolver:
@@ -200,8 +200,8 @@ class DOMBuilder:
         raise NotImplementedError("Haven't written this yet...")
 
     def _parse_bytestream(self, stream, options):
-        import xmlcore.dom.expatbuilder
-        builder = xmlcore.dom.expatbuilder.makeBuilder(options)
+        import xml.dom.expatbuilder
+        builder = xml.dom.expatbuilder.makeBuilder(options)
         return builder.parseFile(stream)
 
 
@@ -340,7 +340,7 @@ class DocumentLS:
         return False
     def _set_async(self, async):
         if async:
-            raise xmlcore.dom.NotSupportedErr(
+            raise xml.dom.NotSupportedErr(
                 "asynchronous document loading is not supported")
 
     def abort(self):
@@ -359,7 +359,7 @@ class DocumentLS:
         if snode is None:
             snode = self
         elif snode.ownerDocument is not self:
-            raise xmlcore.dom.WrongDocumentErr()
+            raise xml.dom.WrongDocumentErr()
         return snode.toxml()
 
 
@@ -369,12 +369,12 @@ class DOMImplementationLS:
 
     def createDOMBuilder(self, mode, schemaType):
         if schemaType is not None:
-            raise xmlcore.dom.NotSupportedErr(
+            raise xml.dom.NotSupportedErr(
                 "schemaType not yet supported")
         if mode == self.MODE_SYNCHRONOUS:
             return DOMBuilder()
         if mode == self.MODE_ASYNCHRONOUS:
-            raise xmlcore.dom.NotSupportedErr(
+            raise xml.dom.NotSupportedErr(
                 "asynchronous builders are not supported")
         raise ValueError("unknown value for mode")
 

Lib/xmlcore/etree/ElementTree.py → Lib/xml/etree/ElementTree.py

@@ -1112,7 +1112,7 @@ class XMLTreeBuilder:
 
     def __init__(self, html=0, target=None):
         try:
-            from xmlcore.parsers import expat
+            from xml.parsers import expat
         except ImportError:
             raise ImportError(
                 "No module named expat; use SimpleXMLTreeBuilder instead"
@@ -1194,7 +1194,7 @@ class XMLTreeBuilder:
             try:
                 self._target.data(self.entity[text[1:-1]])
             except KeyError:
-                from xmlcore.parsers import expat
+                from xml.parsers import expat
                 raise expat.error(
                     "undefined entity %s: line %d, column %d" %
                     (text, self._parser.ErrorLineNumber,

Lib/xmlcore/sax/__init__.py → Lib/xml/sax/__init__.py

@@ -51,12 +51,12 @@ def parseString(string, handler, errorHandler=ErrorHandler()):
 # this is the parser list used by the make_parser function if no
 # alternatives are given as parameters to the function
 
-default_parser_list = ["xmlcore.sax.expatreader"]
+default_parser_list = ["xml.sax.expatreader"]
 
 # tell modulefinder that importing sax potentially imports expatreader
 _false = 0
 if _false:
-    import xmlcore.sax.expatreader
+    import xml.sax.expatreader
 
 import os, sys
 if os.environ.has_key("PY_SAX_PARSER"):

Lib/xmlcore/sax/expatreader.py → Lib/xml/sax/expatreader.py

@@ -5,27 +5,27 @@ pyexpat.__version__ == '2.22'.
 
 version = "0.20"
 
-from xmlcore.sax._exceptions import *
-from xmlcore.sax.handler import feature_validation, feature_namespaces
-from xmlcore.sax.handler import feature_namespace_prefixes
-from xmlcore.sax.handler import feature_external_ges, feature_external_pes
-from xmlcore.sax.handler import feature_string_interning
-from xmlcore.sax.handler import property_xml_string, property_interning_dict
-
-# xmlcore.parsers.expat does not raise ImportError in Jython
+from xml.sax._exceptions import *
+from xml.sax.handler import feature_validation, feature_namespaces
+from xml.sax.handler import feature_namespace_prefixes
+from xml.sax.handler import feature_external_ges, feature_external_pes
+from xml.sax.handler import feature_string_interning
+from xml.sax.handler import property_xml_string, property_interning_dict
+
+# xml.parsers.expat does not raise ImportError in Jython
 import sys
 if sys.platform[:4] == "java":
     raise SAXReaderNotAvailable("expat not available in Java", None)
 del sys
 
 try:
-    from xmlcore.parsers import expat
+    from xml.parsers import expat
 except ImportError:
     raise SAXReaderNotAvailable("expat not supported", None)
 else:
     if not hasattr(expat, "ParserCreate"):
         raise SAXReaderNotAvailable("expat not supported", None)
-from xmlcore.sax import xmlreader, saxutils, handler
+from xml.sax import xmlreader, saxutils, handler
 
 AttributesImpl = xmlreader.AttributesImpl
 AttributesNSImpl = xmlreader.AttributesNSImpl
@@ -407,8 +407,8 @@ def create_parser(*args, **kwargs):
 # ---
 
 if __name__ == "__main__":
-    import xmlcore.sax
+    import xml.sax
     p = create_parser()
-    p.setContentHandler(xmlcore.sax.XMLGenerator())
-    p.setErrorHandler(xmlcore.sax.ErrorHandler())
+    p.setContentHandler(xml.sax.XMLGenerator())
+    p.setErrorHandler(xml.sax.ErrorHandler())
     p.parse("../../../hamlet.xml")

Lib/xmlcore/__init__.py

-"""Core XML support for Python.
-
-This package contains four sub-packages:
-
-dom -- The W3C Document Object Model.  This supports DOM Level 1 +
-       Namespaces.
-
-parsers -- Python wrappers for XML parsers (currently only supports Expat).
-
-sax -- The Simple API for XML, developed by XML-Dev, led by David
-       Megginson and ported to Python by Lars Marius Garshol.  This
-       supports the SAX 2 API.
-
-etree -- The ElementTree XML library.  This is a subset of the full
-       ElementTree XML release.
-
-"""
-
-
-__all__ = ["dom", "parsers", "sax", "etree"]

Makefile.pre.in

@@ -695,7 +695,7 @@ PLATDIR=	plat-$(MACHDEP)
 EXTRAPLATDIR= @EXTRAPLATDIR@
 EXTRAMACHDEPPATH=@EXTRAMACHDEPPATH@
 MACHDEPS=	$(PLATDIR) $(EXTRAPLATDIR)
-XMLLIBSUBDIRS=  xmlcore xmlcore/dom xmlcore/etree xmlcore/parsers xmlcore/sax
+XMLLIBSUBDIRS=  xml xml/dom xml/etree xml/parsers xml/sax
 PLATMACDIRS= plat-mac plat-mac/Carbon plat-mac/lib-scriptpackages \
 	plat-mac/lib-scriptpackages/_builtinSuites \
 	plat-mac/lib-scriptpackages/CodeWarrior \

Misc/NEWS

@@ -52,6 +52,10 @@ Core and builtins
 Library
 -------
 
+- Rename of the xml package to xmlcore, and the import hackery done to
+  make it appear at both names, has been removed.  Bug #1511497,
+  #1513611, and probably others.
+
 - Bug #1441397: The compiler module now recognizes module and function
   docstrings correctly as it did in Python 2.4.
 
@@ -1640,8 +1644,8 @@ Library
 - Bug #792570: SimpleXMLRPCServer had problems if the request grew too large.
   Fixed by reading the HTTP body in chunks instead of one big socket.read().
 
-- Patches #893642, #1039083: add allow_none, encoding arguments to constructors of
-  SimpleXMLRPCServer and CGIXMLRPCRequestHandler.
+- Patches #893642, #1039083: add allow_none, encoding arguments to
+  constructors of SimpleXMLRPCServer and CGIXMLRPCRequestHandler.
 
 - Bug #1110478: Revert os.environ.update to do putenv again.