home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / ZSI / wstools / Utility.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  40.1 KB  |  1,261 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. ident = '$Id: Utility.py 1405 2007-07-10 20:25:44Z boverhof $'
  5. import sys
  6. import types
  7. import httplib
  8. import urllib
  9. import socket
  10. import weakref
  11. import ssl
  12. from os.path import isfile, join as opj, split as ops, exists as ope
  13. from string import join, strip, split
  14. from UserDict import UserDict
  15. from cStringIO import StringIO
  16. from TimeoutSocket import TimeoutSocket, TimeoutError
  17. from urlparse import urlparse
  18. from httplib import HTTPConnection, HTTPSConnection
  19. from exceptions import Exception
  20.  
  21. try:
  22.     from ZSI import _get_idstr
  23. except:
  24.     
  25.     def _get_idstr(pyobj):
  26.         x = id(pyobj)
  27.         if x < 0:
  28.             return 'x%x' % abs(x)
  29.         return 'o%x' % x
  30.  
  31.  
  32. import xml.dom.minidom as xml
  33. from xml.dom import Node
  34. import logging
  35. from c14n import Canonicalize
  36. from Namespaces import SCHEMA, SOAP, XMLNS, ZSI_SCHEMA_URI
  37.  
  38. try:
  39.     from xml.dom.ext import SplitQName
  40. except:
  41.     
  42.     def SplitQName(qname):
  43.         l = qname.split(':')
  44.         if len(l) == 1:
  45.             l.insert(0, None)
  46.         elif len(l) == 2:
  47.             if l[0] == 'xmlns':
  48.                 l.reverse()
  49.             
  50.         else:
  51.             return None
  52.         return len(l) == 1(l)
  53.  
  54.  
  55.  
  56. def basejoin(head, tail):
  57.     res = opj(ops(head)[0], tail)
  58.     if ope(res):
  59.         return res
  60.     return urllib.basejoin(head, tail)
  61.  
  62. if sys.version_info[0:2] < (2, 4, 0, 'final', 0)[0:2]:
  63.     token = './'
  64.     
  65.     def basejoin(base, url):
  66.         if url.startswith(token) is True:
  67.             return urllib.basejoin(base, url[2:])
  68.         return urllib.basejoin(base, url)
  69.  
  70.  
  71.  
  72. class NamespaceError(Exception):
  73.     pass
  74.  
  75.  
  76. class RecursionError(Exception):
  77.     pass
  78.  
  79.  
  80. class ParseError(Exception):
  81.     pass
  82.  
  83.  
  84. class DOMException(Exception):
  85.     pass
  86.  
  87.  
  88. class Base:
  89.     
  90.     def __init__(self, module = __name__):
  91.         self.logger = logging.getLogger('%s-%s(%s)' % (module, self.__class__, _get_idstr(self)))
  92.  
  93.  
  94.  
  95. class HTTPResponse:
  96.     
  97.     def __init__(self, response):
  98.         self.status = response.status
  99.         self.reason = response.reason
  100.         self.headers = response.msg
  101.         if not response.read():
  102.             pass
  103.         self.body = None
  104.         response.close()
  105.  
  106.  
  107.  
  108. class TimeoutHTTP(HTTPConnection):
  109.     
  110.     def __init__(self, host, port = None, timeout = 20):
  111.         HTTPConnection.__init__(self, host, port)
  112.         self.timeout = timeout
  113.  
  114.     
  115.     def connect(self):
  116.         self.sock = TimeoutSocket(self.timeout)
  117.         self.sock.connect((self.host, self.port))
  118.  
  119.  
  120.  
  121. class TimeoutHTTPS(HTTPSConnection):
  122.     
  123.     def __init__(self, host, port = None, timeout = 20, **kwargs):
  124.         HTTPSConnection.__init__(self, str(host), port, **kwargs)
  125.         self.timeout = timeout
  126.  
  127.     
  128.     def connect(self):
  129.         sock = TimeoutSocket(self.timeout)
  130.         sock.connect((self.host, self.port))
  131.         realsock = getattr(sock.sock, '_sock', sock.sock)
  132.         self.sock = ssl.wrap_socket(realsock, self.key_file, self.cert_file)
  133.  
  134.  
  135.  
  136. def urlopen(url, timeout = 20, redirects = None):
  137.     (scheme, host, path, params, query, frag) = urlparse(url)
  138.     if scheme not in ('http', 'https'):
  139.         return urllib.urlopen(url)
  140.     if params:
  141.         path = '%s;%s' % (path, params)
  142.     
  143.     if query:
  144.         path = '%s?%s' % (path, query)
  145.     
  146.     if frag:
  147.         path = '%s#%s' % (path, frag)
  148.     
  149.     if scheme == 'https':
  150.         
  151.         try:
  152.             import M2Crypto
  153.         except ImportError:
  154.             if not hasattr(socket, 'ssl'):
  155.                 raise RuntimeError, 'no built-in SSL Support'
  156.             hasattr(socket, 'ssl')
  157.             conn = TimeoutHTTPS(host, None, timeout)
  158.  
  159.         ctx = M2Crypto.SSL.Context()
  160.         ctx.set_session_timeout(timeout)
  161.         conn = M2Crypto.httpslib.HTTPSConnection(host, ssl_context = ctx)
  162.         conn.set_debuglevel(1)
  163.     else:
  164.         conn = TimeoutHTTP(host, None, timeout)
  165.     conn.putrequest('GET', path)
  166.     conn.putheader('Connection', 'close')
  167.     conn.endheaders()
  168.     response = None
  169.     while None:
  170.         response = conn.getresponse()
  171.         if response.status != 100:
  172.             break
  173.         
  174.         conn._HTTPConnection__state = httplib._CS_REQ_SENT
  175.         conn._HTTPConnection__response = None
  176.         continue
  177.         status = response.status
  178.         if status >= 300 and status < 400:
  179.             location = response.msg.getheader('location')
  180.             if location is not None:
  181.                 response.close()
  182.                 if redirects is not None and redirects.has_key(location):
  183.                     raise RecursionError('Circular HTTP redirection detected.')
  184.                 redirects.has_key(location)
  185.                 if redirects is None:
  186.                     redirects = { }
  187.                 
  188.                 redirects[location] = 1
  189.                 return urlopen(location, timeout, redirects)
  190.             raise HTTPResponse(response)
  191.         if not status >= 200 and status < 300:
  192.             raise HTTPResponse(response)
  193.         status < 300
  194.         body = StringIO(response.read())
  195.         response.close()
  196.         return body
  197.  
  198.  
  199. class DOM:
  200.     NS_SOAP_ENV_1_1 = 'http://schemas.xmlsoap.org/soap/envelope/'
  201.     NS_SOAP_ENC_1_1 = 'http://schemas.xmlsoap.org/soap/encoding/'
  202.     NS_SOAP_ENV_1_2 = 'http://www.w3.org/2001/06/soap-envelope'
  203.     NS_SOAP_ENC_1_2 = 'http://www.w3.org/2001/06/soap-encoding'
  204.     NS_SOAP_ENV_ALL = (NS_SOAP_ENV_1_1, NS_SOAP_ENV_1_2)
  205.     NS_SOAP_ENC_ALL = (NS_SOAP_ENC_1_1, NS_SOAP_ENC_1_2)
  206.     NS_SOAP_ENV = NS_SOAP_ENV_1_1
  207.     NS_SOAP_ENC = NS_SOAP_ENC_1_1
  208.     _soap_uri_mapping = {
  209.         NS_SOAP_ENV_1_1: '1.1',
  210.         NS_SOAP_ENV_1_2: '1.2' }
  211.     SOAP_ACTOR_NEXT_1_1 = 'http://schemas.xmlsoap.org/soap/actor/next'
  212.     SOAP_ACTOR_NEXT_1_2 = 'http://www.w3.org/2001/06/soap-envelope/actor/next'
  213.     SOAP_ACTOR_NEXT_ALL = (SOAP_ACTOR_NEXT_1_1, SOAP_ACTOR_NEXT_1_2)
  214.     
  215.     def SOAPUriToVersion(self, uri):
  216.         value = self._soap_uri_mapping.get(uri)
  217.         if value is not None:
  218.             return value
  219.         raise ValueError('Unsupported SOAP envelope uri: %s' % uri)
  220.  
  221.     
  222.     def GetSOAPEnvUri(self, version):
  223.         attrname = 'NS_SOAP_ENV_%s' % join(split(version, '.'), '_')
  224.         value = getattr(self, attrname, None)
  225.         if value is not None:
  226.             return value
  227.         raise ValueError('Unsupported SOAP version: %s' % version)
  228.  
  229.     
  230.     def GetSOAPEncUri(self, version):
  231.         attrname = 'NS_SOAP_ENC_%s' % join(split(version, '.'), '_')
  232.         value = getattr(self, attrname, None)
  233.         if value is not None:
  234.             return value
  235.         raise ValueError('Unsupported SOAP version: %s' % version)
  236.  
  237.     
  238.     def GetSOAPActorNextUri(self, version):
  239.         attrname = 'SOAP_ACTOR_NEXT_%s' % join(split(version, '.'), '_')
  240.         value = getattr(self, attrname, None)
  241.         if value is not None:
  242.             return value
  243.         raise ValueError('Unsupported SOAP version: %s' % version)
  244.  
  245.     NS_XSD_99 = 'http://www.w3.org/1999/XMLSchema'
  246.     NS_XSI_99 = 'http://www.w3.org/1999/XMLSchema-instance'
  247.     NS_XSD_00 = 'http://www.w3.org/2000/10/XMLSchema'
  248.     NS_XSI_00 = 'http://www.w3.org/2000/10/XMLSchema-instance'
  249.     NS_XSD_01 = 'http://www.w3.org/2001/XMLSchema'
  250.     NS_XSI_01 = 'http://www.w3.org/2001/XMLSchema-instance'
  251.     NS_XSD_ALL = (NS_XSD_99, NS_XSD_00, NS_XSD_01)
  252.     NS_XSI_ALL = (NS_XSI_99, NS_XSI_00, NS_XSI_01)
  253.     NS_XSD = NS_XSD_01
  254.     NS_XSI = NS_XSI_01
  255.     _xsd_uri_mapping = {
  256.         NS_XSD_99: NS_XSI_99,
  257.         NS_XSD_00: NS_XSI_00,
  258.         NS_XSD_01: NS_XSI_01 }
  259.     for key, value in _xsd_uri_mapping.items():
  260.         _xsd_uri_mapping[value] = key
  261.     
  262.     
  263.     def InstanceUriForSchemaUri(self, uri):
  264.         return self._xsd_uri_mapping.get(uri)
  265.  
  266.     
  267.     def SchemaUriForInstanceUri(self, uri):
  268.         return self._xsd_uri_mapping.get(uri)
  269.  
  270.     NS_WSDL_1_1 = 'http://schemas.xmlsoap.org/wsdl/'
  271.     NS_WSDL_ALL = (NS_WSDL_1_1,)
  272.     NS_WSDL = NS_WSDL_1_1
  273.     NS_SOAP_BINDING_1_1 = 'http://schemas.xmlsoap.org/wsdl/soap/'
  274.     NS_SOAP_BINDING_1_2 = 'http://schemas.xmlsoap.org/wsdl/soap12/'
  275.     NS_HTTP_BINDING_1_1 = 'http://schemas.xmlsoap.org/wsdl/http/'
  276.     NS_MIME_BINDING_1_1 = 'http://schemas.xmlsoap.org/wsdl/mime/'
  277.     NS_SOAP_BINDING_ALL = (NS_SOAP_BINDING_1_1, NS_SOAP_BINDING_1_2)
  278.     NS_HTTP_BINDING_ALL = (NS_HTTP_BINDING_1_1,)
  279.     NS_MIME_BINDING_ALL = (NS_MIME_BINDING_1_1,)
  280.     NS_SOAP_BINDING = NS_SOAP_BINDING_1_1
  281.     NS_HTTP_BINDING = NS_HTTP_BINDING_1_1
  282.     NS_MIME_BINDING = NS_MIME_BINDING_1_1
  283.     NS_SOAP_HTTP_1_1 = 'http://schemas.xmlsoap.org/soap/http'
  284.     NS_SOAP_HTTP_ALL = (NS_SOAP_HTTP_1_1,)
  285.     NS_SOAP_HTTP = NS_SOAP_HTTP_1_1
  286.     _wsdl_uri_mapping = {
  287.         NS_WSDL_1_1: '1.1' }
  288.     
  289.     def WSDLUriToVersion(self, uri):
  290.         value = self._wsdl_uri_mapping.get(uri)
  291.         if value is not None:
  292.             return value
  293.         raise ValueError('Unsupported SOAP envelope uri: %s' % uri)
  294.  
  295.     
  296.     def GetWSDLUri(self, version):
  297.         attr = 'NS_WSDL_%s' % join(split(version, '.'), '_')
  298.         value = getattr(self, attr, None)
  299.         if value is not None:
  300.             return value
  301.         raise ValueError('Unsupported WSDL version: %s' % version)
  302.  
  303.     
  304.     def GetWSDLSoapBindingUri(self, version):
  305.         attr = 'NS_SOAP_BINDING_%s' % join(split(version, '.'), '_')
  306.         value = getattr(self, attr, None)
  307.         if value is not None:
  308.             return value
  309.         raise ValueError('Unsupported WSDL version: %s' % version)
  310.  
  311.     
  312.     def GetWSDLHttpBindingUri(self, version):
  313.         attr = 'NS_HTTP_BINDING_%s' % join(split(version, '.'), '_')
  314.         value = getattr(self, attr, None)
  315.         if value is not None:
  316.             return value
  317.         raise ValueError('Unsupported WSDL version: %s' % version)
  318.  
  319.     
  320.     def GetWSDLMimeBindingUri(self, version):
  321.         attr = 'NS_MIME_BINDING_%s' % join(split(version, '.'), '_')
  322.         value = getattr(self, attr, None)
  323.         if value is not None:
  324.             return value
  325.         raise ValueError('Unsupported WSDL version: %s' % version)
  326.  
  327.     
  328.     def GetWSDLHttpTransportUri(self, version):
  329.         attr = 'NS_SOAP_HTTP_%s' % join(split(version, '.'), '_')
  330.         value = getattr(self, attr, None)
  331.         if value is not None:
  332.             return value
  333.         raise ValueError('Unsupported WSDL version: %s' % version)
  334.  
  335.     NS_XMLNS = 'http://www.w3.org/2000/xmlns/'
  336.     
  337.     def isElement(self, node, name, nsuri = None):
  338.         if node.nodeType != node.ELEMENT_NODE:
  339.             return 0
  340.         if not node.localName == name and nsuri is None:
  341.             pass
  342.         return self.nsUriMatch(node.namespaceURI, nsuri)
  343.  
  344.     
  345.     def getElement(self, node, name, nsuri = None, default = join):
  346.         nsmatch = self.nsUriMatch
  347.         ELEMENT_NODE = node.ELEMENT_NODE
  348.         for child in node.childNodes:
  349.             if child.nodeType == ELEMENT_NODE:
  350.                 if child.localName == name or name is None:
  351.                     if nsuri is None or nsmatch(child.namespaceURI, nsuri):
  352.                         return child
  353.                     continue
  354.                     nsmatch(child.namespaceURI, nsuri)
  355.                 if default is not join:
  356.                     return default
  357.                 raise KeyError, name
  358.             return child.nodeType == ELEMENT_NODE
  359.  
  360.     
  361.     def getElementById(self, node, id, default = join):
  362.         attrget = self.getAttr
  363.         ELEMENT_NODE = node.ELEMENT_NODE
  364.         for child in node.childNodes:
  365.             if child.nodeType == ELEMENT_NODE:
  366.                 if attrget(child, 'id') == id:
  367.                     return child
  368.                 continue
  369.             attrget(child, 'id') == id
  370.         
  371.         if default is not join:
  372.             return default
  373.         raise KeyError, name
  374.  
  375.     
  376.     def getMappingById(self, document, depth = None, element = None, mapping = None, level = 1):
  377.         if document is not None:
  378.             element = document.documentElement
  379.             mapping = { }
  380.         
  381.         attr = element._attrs.get('id', None)
  382.         if attr is not None:
  383.             mapping[attr.value] = element
  384.         
  385.         if depth is None or depth > level:
  386.             level = level + 1
  387.             ELEMENT_NODE = element.ELEMENT_NODE
  388.             for child in element.childNodes:
  389.                 if child.nodeType == ELEMENT_NODE:
  390.                     self.getMappingById(None, depth, child, mapping, level)
  391.                     continue
  392.             
  393.         
  394.         return mapping
  395.  
  396.     
  397.     def getElements(self, node, name, nsuri = None):
  398.         nsmatch = self.nsUriMatch
  399.         result = []
  400.         ELEMENT_NODE = node.ELEMENT_NODE
  401.         for child in node.childNodes:
  402.             if child.nodeType == ELEMENT_NODE:
  403.                 if child.localName == name or name is None:
  404.                     pass
  405.                 None if nsuri is None or nsmatch(child.namespaceURI, nsuri) else nsmatch(child.namespaceURI, nsuri)
  406.                 continue
  407.         
  408.         return result
  409.  
  410.     
  411.     def hasAttr(self, node, name, nsuri = None):
  412.         if nsuri is None:
  413.             if node.hasAttribute(name):
  414.                 return True
  415.             return False
  416.         return node.hasAttributeNS(nsuri, name)
  417.  
  418.     
  419.     def getAttr(self, node, name, nsuri = None, default = join):
  420.         if nsuri is None:
  421.             result = node._attrs.get(name, None)
  422.             if result is None:
  423.                 for item in node._attrsNS.keys():
  424.                     if item[1] == name:
  425.                         result = node._attrsNS[item]
  426.                         break
  427.                         continue
  428.                 
  429.             
  430.         else:
  431.             result = node._attrsNS.get((nsuri, name), None)
  432.         if result is not None:
  433.             return result.value
  434.         if default is not join:
  435.             return default
  436.         return ''
  437.  
  438.     
  439.     def getAttrs(self, node):
  440.         attrs = { }
  441.         for k, v in node._attrs.items():
  442.             attrs[k] = v.value
  443.         
  444.         return attrs
  445.  
  446.     
  447.     def getElementText(self, node, preserve_ws = None):
  448.         result = []
  449.         for child in node.childNodes:
  450.             nodetype = child.nodeType
  451.             if nodetype == child.TEXT_NODE or nodetype == child.CDATA_SECTION_NODE:
  452.                 result.append(child.nodeValue)
  453.                 continue
  454.         
  455.         value = join(result, '')
  456.         if preserve_ws is None:
  457.             value = strip(value)
  458.         
  459.         return value
  460.  
  461.     
  462.     def findNamespaceURI(self, prefix, node):
  463.         attrkey = (self.NS_XMLNS, prefix)
  464.         DOCUMENT_NODE = node.DOCUMENT_NODE
  465.         ELEMENT_NODE = node.ELEMENT_NODE
  466.         while node is None:
  467.             raise DOMException('Value for prefix %s not found.' % prefix)
  468.         if node.nodeType != ELEMENT_NODE:
  469.             node = node.parentNode
  470.             continue
  471.         
  472.         result = node._attrsNS.get(attrkey, None)
  473.         if result is not None:
  474.             return result.value
  475.         if hasattr(node, '__imported__'):
  476.             raise DOMException('Value for prefix %s not found.' % prefix)
  477.         hasattr(node, '__imported__')
  478.         node = node.parentNode
  479.         if node.nodeType == DOCUMENT_NODE:
  480.             raise DOMException('Value for prefix %s not found.' % prefix)
  481.         node.nodeType == DOCUMENT_NODE
  482.         continue
  483.  
  484.     
  485.     def findDefaultNS(self, node):
  486.         attrkey = (self.NS_XMLNS, 'xmlns')
  487.         DOCUMENT_NODE = node.DOCUMENT_NODE
  488.         ELEMENT_NODE = node.ELEMENT_NODE
  489.         while node.nodeType != ELEMENT_NODE:
  490.             node = node.parentNode
  491.             continue
  492.         result = node._attrsNS.get(attrkey, None)
  493.         if result is not None:
  494.             return result.value
  495.         if hasattr(node, '__imported__'):
  496.             raise DOMException('Cannot determine default namespace.')
  497.         hasattr(node, '__imported__')
  498.         node = node.parentNode
  499.         if node.nodeType == DOCUMENT_NODE:
  500.             raise DOMException('Cannot determine default namespace.')
  501.         node.nodeType == DOCUMENT_NODE
  502.         continue
  503.  
  504.     
  505.     def findTargetNS(self, node):
  506.         attrget = self.getAttr
  507.         attrkey = (self.NS_XMLNS, 'xmlns')
  508.         DOCUMENT_NODE = node.DOCUMENT_NODE
  509.         ELEMENT_NODE = node.ELEMENT_NODE
  510.         while node.nodeType != ELEMENT_NODE:
  511.             node = node.parentNode
  512.             continue
  513.         result = attrget(node, 'targetNamespace', default = None)
  514.         if result is not None:
  515.             return result
  516.         node = node.parentNode
  517.         if node.nodeType == DOCUMENT_NODE:
  518.             raise DOMException('Cannot determine target namespace.')
  519.         node.nodeType == DOCUMENT_NODE
  520.         continue
  521.  
  522.     
  523.     def getTypeRef(self, element):
  524.         typeattr = self.getAttr(element, 'type', default = None)
  525.         if typeattr is None:
  526.             return None
  527.         parts = typeattr.split(':', 1)
  528.         if len(parts) == 2:
  529.             nsuri = self.findNamespaceURI(parts[0], element)
  530.         else:
  531.             nsuri = self.findDefaultNS(element)
  532.         return (nsuri, parts[1])
  533.  
  534.     
  535.     def importNode(self, document, node, deep = 0):
  536.         nodetype = node.nodeType
  537.         if nodetype in (node.DOCUMENT_NODE, node.DOCUMENT_TYPE_NODE):
  538.             raise DOMException('Illegal node type for importNode')
  539.         nodetype in (node.DOCUMENT_NODE, node.DOCUMENT_TYPE_NODE)
  540.         if nodetype == node.ENTITY_REFERENCE_NODE:
  541.             deep = 0
  542.         
  543.         clone = node.cloneNode(deep)
  544.         self._setOwnerDoc(document, clone)
  545.         clone.__imported__ = 1
  546.         return clone
  547.  
  548.     
  549.     def _setOwnerDoc(self, document, node):
  550.         node.ownerDocument = document
  551.         for child in node.childNodes:
  552.             self._setOwnerDoc(document, child)
  553.         
  554.  
  555.     
  556.     def nsUriMatch(self, value, wanted, strict = 0, tt = type(())):
  557.         if (value == wanted or type(wanted) is tt) and value in wanted:
  558.             return 1
  559.         return 0
  560.  
  561.     
  562.     def createDocument(self, nsuri, qname, doctype = None):
  563.         impl = xml.dom.minidom.getDOMImplementation()
  564.         return impl.createDocument(nsuri, qname, doctype)
  565.  
  566.     
  567.     def loadDocument(self, data):
  568.         return xml.dom.minidom.parse(data)
  569.  
  570.     
  571.     def loadFromURL(self, url):
  572.         if isfile(url) is True:
  573.             file = open(url, 'r')
  574.         else:
  575.             file = urlopen(url)
  576.         
  577.         try:
  578.             result = self.loadDocument(file)
  579.         except Exception:
  580.             ex = None
  581.             file.close()
  582.             raise ParseError(('Failed to load document %s' % url,) + ex.args)
  583.  
  584.         file.close()
  585.         return result
  586.  
  587.  
  588. DOM = DOM()
  589.  
  590. class MessageInterface:
  591.     
  592.     def __init__(self, sw):
  593.         self.sw = None
  594.         if type(sw) != weakref.ReferenceType and sw is not None:
  595.             self.sw = weakref.ref(sw)
  596.         else:
  597.             self.sw = sw
  598.  
  599.     
  600.     def AddCallback(self, func, *arglist):
  601.         self.sw().AddCallback(func, *arglist)
  602.  
  603.     
  604.     def Known(self, obj):
  605.         return self.sw().Known(obj)
  606.  
  607.     
  608.     def Forget(self, obj):
  609.         return self.sw().Forget(obj)
  610.  
  611.     
  612.     def canonicalize(self):
  613.         raise NotImplementedError, ''
  614.  
  615.     
  616.     def createDocument(self, namespaceURI = SOAP.ENV, localName = 'Envelope'):
  617.         raise NotImplementedError, ''
  618.  
  619.     
  620.     def createAppendElement(self, namespaceURI, localName):
  621.         raise NotImplementedError, ''
  622.  
  623.     
  624.     def findNamespaceURI(self, qualifiedName):
  625.         raise NotImplementedError, ''
  626.  
  627.     
  628.     def resolvePrefix(self, prefix):
  629.         raise NotImplementedError, ''
  630.  
  631.     
  632.     def setAttributeNS(self, namespaceURI, localName, value):
  633.         raise NotImplementedError, ''
  634.  
  635.     
  636.     def setAttributeType(self, namespaceURI, localName):
  637.         raise NotImplementedError, ''
  638.  
  639.     
  640.     def setNamespaceAttribute(self, namespaceURI, prefix):
  641.         raise NotImplementedError, ''
  642.  
  643.  
  644.  
  645. class ElementProxy(Base, MessageInterface):
  646.     _soap_env_prefix = 'SOAP-ENV'
  647.     _soap_enc_prefix = 'SOAP-ENC'
  648.     _zsi_prefix = 'ZSI'
  649.     _xsd_prefix = 'xsd'
  650.     _xsi_prefix = 'xsi'
  651.     _xml_prefix = 'xml'
  652.     _xmlns_prefix = 'xmlns'
  653.     _soap_env_nsuri = SOAP.ENV
  654.     _soap_env12_nsuri = SOAP.ENV12
  655.     _soap_enc_nsuri = SOAP.ENC
  656.     _soap_enc12_nsuri = SOAP.ENC12
  657.     _zsi_nsuri = ZSI_SCHEMA_URI
  658.     _xsd_nsuri = SCHEMA.XSD3
  659.     _xsi_nsuri = SCHEMA.XSI3
  660.     _xml_nsuri = XMLNS.XML
  661.     _xmlns_nsuri = XMLNS.BASE
  662.     standard_ns = {
  663.         _xml_prefix: _xml_nsuri,
  664.         _xmlns_prefix: _xmlns_nsuri }
  665.     reserved_ns = {
  666.         _soap_env_prefix: _soap_env_nsuri,
  667.         _soap_enc_prefix: _soap_enc_nsuri,
  668.         _zsi_prefix: _zsi_nsuri,
  669.         _xsd_prefix: _xsd_nsuri,
  670.         _xsi_prefix: _xsi_nsuri }
  671.     name = None
  672.     namespaceURI = None
  673.     
  674.     def __init__(self, sw, message = None):
  675.         self._indx = 0
  676.         MessageInterface.__init__(self, sw)
  677.         Base.__init__(self)
  678.         self._dom = DOM
  679.         self.node = None
  680.         if type(message) in (types.StringType, types.UnicodeType):
  681.             self.loadFromString(message)
  682.         elif isinstance(message, ElementProxy):
  683.             self.node = message._getNode()
  684.         else:
  685.             self.node = message
  686.         self.processorNss = self.standard_ns.copy()
  687.         self.processorNss.update(self.reserved_ns)
  688.  
  689.     
  690.     def __str__(self):
  691.         return self.toString()
  692.  
  693.     
  694.     def evaluate(self, expression, processorNss = None):
  695.         XPath = XPath
  696.         import Ft.Xml
  697.         if not processorNss:
  698.             context = XPath.Context.Context(self.node, processorNss = self.processorNss)
  699.         else:
  700.             context = XPath.Context.Context(self.node, processorNss = processorNss)
  701.         nodes = expression.evaluate(context)
  702.         return (map,)((lambda node: ElementProxy(self.sw, node)), nodes)
  703.  
  704.     
  705.     def checkNode(self, namespaceURI = None, localName = None):
  706.         if not namespaceURI:
  707.             pass
  708.         namespaceURI = self.namespaceURI
  709.         if not localName:
  710.             pass
  711.         localName = self.name
  712.         check = False
  713.         if localName and self.node:
  714.             check = self._dom.isElement(self.node, localName, namespaceURI)
  715.         
  716.         if not check:
  717.             raise NamespaceError, 'unexpected node type %s, expecting %s' % (self.node, localName)
  718.         check
  719.  
  720.     
  721.     def setNode(self, node = None):
  722.         if node:
  723.             if isinstance(node, ElementProxy):
  724.                 self.node = node._getNode()
  725.             else:
  726.                 self.node = node
  727.         elif self.node:
  728.             node = self._dom.getElement(self.node, self.name, self.namespaceURI, default = None)
  729.             if not node:
  730.                 raise NamespaceError, 'cant find element (%s,%s)' % (self.namespaceURI, self.name)
  731.             node
  732.             self.node = node
  733.         else:
  734.             self.createDocument(self.namespaceURI, localName = self.name, doctype = None)
  735.         self.checkNode()
  736.  
  737.     
  738.     def _getNode(self):
  739.         return self.node
  740.  
  741.     
  742.     def _getElements(self):
  743.         return self._dom.getElements(self.node, name = None)
  744.  
  745.     
  746.     def _getOwnerDocument(self):
  747.         if not self.node.ownerDocument:
  748.             pass
  749.         return self.node
  750.  
  751.     
  752.     def _getUniquePrefix(self):
  753.         while None:
  754.             self._indx += 1
  755.             prefix = 'ns%d' % self._indx
  756.             
  757.             try:
  758.                 self._dom.findNamespaceURI(prefix, self._getNode())
  759.             continue
  760.             except DOMException:
  761.                 self
  762.                 ex = self
  763.                 break
  764.                 continue
  765.             
  766.  
  767.             return prefix
  768.  
  769.     
  770.     def _getPrefix(self, node, nsuri):
  771.         
  772.         try:
  773.             if node and node.nodeType == node.ELEMENT_NODE and nsuri == self._dom.findDefaultNS(node):
  774.                 return None
  775.         except DOMException:
  776.             ex = None
  777.  
  778.         if nsuri == XMLNS.XML:
  779.             return self._xml_prefix
  780.         if node.nodeType == Node.ELEMENT_NODE:
  781.             for attr in node.attributes.values():
  782.                 if attr.namespaceURI == XMLNS.BASE and nsuri == attr.value:
  783.                     return attr.localName
  784.             elif node.parentNode:
  785.                 return self._getPrefix(node.parentNode, nsuri)
  786.             nsuri == attr.value
  787.         
  788.         raise NamespaceError, 'namespaceURI "%s" is not defined' % nsuri
  789.  
  790.     
  791.     def _appendChild(self, node):
  792.         if node is None:
  793.             raise TypeError, 'node is None'
  794.         node is None
  795.         self.node.appendChild(node)
  796.  
  797.     
  798.     def _insertBefore(self, newChild, refChild):
  799.         self.node.insertBefore(newChild, refChild)
  800.  
  801.     
  802.     def _setAttributeNS(self, namespaceURI, qualifiedName, value):
  803.         self.node.setAttributeNS(namespaceURI, qualifiedName, value)
  804.  
  805.     
  806.     def isFault(self):
  807.         return False
  808.  
  809.     
  810.     def getPrefix(self, namespaceURI):
  811.         
  812.         try:
  813.             prefix = self._getPrefix(node = self.node, nsuri = namespaceURI)
  814.         except NamespaceError:
  815.             ex = None
  816.             prefix = self._getUniquePrefix()
  817.             self.setNamespaceAttribute(prefix, namespaceURI)
  818.  
  819.         return prefix
  820.  
  821.     
  822.     def getDocument(self):
  823.         return self._getOwnerDocument()
  824.  
  825.     
  826.     def setDocument(self, document):
  827.         self.node = document
  828.  
  829.     
  830.     def importFromString(self, xmlString):
  831.         doc = self._dom.loadDocument(StringIO(xmlString))
  832.         node = self._dom.getElement(doc, name = None)
  833.         clone = self.importNode(node)
  834.         self._appendChild(clone)
  835.  
  836.     
  837.     def importNode(self, node):
  838.         if isinstance(node, ElementProxy):
  839.             node = node._getNode()
  840.         
  841.         return self._dom.importNode(self._getOwnerDocument(), node, deep = 1)
  842.  
  843.     
  844.     def loadFromString(self, data):
  845.         self.node = self._dom.loadDocument(StringIO(data))
  846.  
  847.     
  848.     def canonicalize(self):
  849.         return Canonicalize(self.node)
  850.  
  851.     
  852.     def toString(self):
  853.         return self.canonicalize()
  854.  
  855.     
  856.     def createDocument(self, namespaceURI, localName, doctype = None):
  857.         prefix = self._soap_env_prefix
  858.         if namespaceURI == self.reserved_ns[prefix]:
  859.             qualifiedName = '%s:%s' % (prefix, localName)
  860.         elif localName is localName:
  861.             pass
  862.         elif localName is None:
  863.             self.node = self._dom.createDocument(None, None, None)
  864.             return None
  865.         raise KeyError, 'only support creation of document in %s' % self.reserved_ns[prefix]
  866.         document = self._dom.createDocument(nsuri = namespaceURI, qname = qualifiedName, doctype = doctype)
  867.         self.node = document.childNodes[0]
  868.         for prefix, nsuri in self.reserved_ns.items():
  869.             self._setAttributeNS(namespaceURI = self._xmlns_nsuri, qualifiedName = '%s:%s' % (self._xmlns_prefix, prefix), value = nsuri)
  870.         
  871.  
  872.     
  873.     def hasAttribute(self, namespaceURI, localName):
  874.         return self._dom.hasAttr(self._getNode(), name = localName, nsuri = namespaceURI)
  875.  
  876.     
  877.     def setAttributeType(self, namespaceURI, localName):
  878.         self.logger.debug('setAttributeType: (%s,%s)', namespaceURI, localName)
  879.         value = localName
  880.         if namespaceURI:
  881.             value = '%s:%s' % (self.getPrefix(namespaceURI), localName)
  882.         
  883.         xsi_prefix = self.getPrefix(self._xsi_nsuri)
  884.         self._setAttributeNS(self._xsi_nsuri, '%s:type' % xsi_prefix, value)
  885.  
  886.     
  887.     def createAttributeNS(self, namespace, name, value):
  888.         document = self._getOwnerDocument()
  889.         attrNode = document.createAttributeNS(namespace, name, value)
  890.  
  891.     
  892.     def setAttributeNS(self, namespaceURI, localName, value):
  893.         prefix = None
  894.         if namespaceURI:
  895.             
  896.             try:
  897.                 prefix = self.getPrefix(namespaceURI)
  898.             except KeyError:
  899.                 ex = None
  900.                 prefix = 'ns2'
  901.                 self.setNamespaceAttribute(prefix, namespaceURI)
  902.             except:
  903.                 None<EXCEPTION MATCH>KeyError
  904.             
  905.  
  906.         None<EXCEPTION MATCH>KeyError
  907.         qualifiedName = localName
  908.         if prefix:
  909.             qualifiedName = '%s:%s' % (prefix, localName)
  910.         
  911.         self._setAttributeNS(namespaceURI, qualifiedName, value)
  912.  
  913.     
  914.     def setNamespaceAttribute(self, prefix, namespaceURI):
  915.         self._setAttributeNS(XMLNS.BASE, 'xmlns:%s' % prefix, namespaceURI)
  916.  
  917.     
  918.     def createElementNS(self, namespace, qname):
  919.         document = self._getOwnerDocument()
  920.         node = document.createElementNS(namespace, qname)
  921.         return ElementProxy(self.sw, node)
  922.  
  923.     
  924.     def createAppendSetElement(self, namespaceURI, localName, prefix = None):
  925.         node = self.createAppendElement(namespaceURI, localName, prefix = None)
  926.         node = node._getNode()
  927.         self._setNode(node._getNode())
  928.  
  929.     
  930.     def createAppendElement(self, namespaceURI, localName, prefix = None):
  931.         declare = False
  932.         qualifiedName = localName
  933.         if namespaceURI:
  934.             
  935.             try:
  936.                 prefix = self.getPrefix(namespaceURI)
  937.             except:
  938.                 declare = True
  939.                 if not prefix:
  940.                     pass
  941.                 prefix = self._getUniquePrefix()
  942.  
  943.             if prefix:
  944.                 qualifiedName = '%s:%s' % (prefix, localName)
  945.             
  946.         
  947.         node = self.createElementNS(namespaceURI, qualifiedName)
  948.         if declare:
  949.             node._setAttributeNS(XMLNS.BASE, 'xmlns:%s' % prefix, namespaceURI)
  950.         
  951.         self._appendChild(node = node._getNode())
  952.         return node
  953.  
  954.     
  955.     def createInsertBefore(self, namespaceURI, localName, refChild):
  956.         qualifiedName = localName
  957.         prefix = self.getPrefix(namespaceURI)
  958.         if prefix:
  959.             qualifiedName = '%s:%s' % (prefix, localName)
  960.         
  961.         node = self.createElementNS(namespaceURI, qualifiedName)
  962.         self._insertBefore(newChild = node._getNode(), refChild = refChild._getNode())
  963.         return node
  964.  
  965.     
  966.     def getElement(self, namespaceURI, localName):
  967.         node = self._dom.getElement(self.node, localName, namespaceURI, default = None)
  968.         if node:
  969.             return ElementProxy(self.sw, node)
  970.  
  971.     
  972.     def getAttributeValue(self, namespaceURI, localName):
  973.         if self.hasAttribute(namespaceURI, localName):
  974.             attr = self.node.getAttributeNodeNS(namespaceURI, localName)
  975.             return attr.value
  976.  
  977.     
  978.     def getValue(self):
  979.         return self._dom.getElementText(self.node, preserve_ws = True)
  980.  
  981.     
  982.     def createAppendTextNode(self, pyobj):
  983.         node = self.createTextNode(pyobj)
  984.         self._appendChild(node = node._getNode())
  985.         return node
  986.  
  987.     
  988.     def createTextNode(self, pyobj):
  989.         document = self._getOwnerDocument()
  990.         node = document.createTextNode(pyobj)
  991.         return ElementProxy(self.sw, node)
  992.  
  993.     
  994.     def findNamespaceURI(self, qualifiedName):
  995.         parts = SplitQName(qualifiedName)
  996.         element = self._getNode()
  997.         if len(parts) == 1:
  998.             return (self._dom.findTargetNS(element), value)
  999.         return self._dom.findNamespaceURI(parts[0], element)
  1000.  
  1001.     
  1002.     def resolvePrefix(self, prefix):
  1003.         element = self._getNode()
  1004.         return self._dom.findNamespaceURI(prefix, element)
  1005.  
  1006.     
  1007.     def getSOAPEnvURI(self):
  1008.         return self._soap_env_nsuri
  1009.  
  1010.     
  1011.     def isEmpty(self):
  1012.         return not (self.node)
  1013.  
  1014.  
  1015.  
  1016. class Collection(UserDict):
  1017.     
  1018.     default = lambda self, k: k.name
  1019.     
  1020.     def __init__(self, parent, key = None):
  1021.         UserDict.__init__(self)
  1022.         self.parent = weakref.ref(parent)
  1023.         self.list = []
  1024.         if not key:
  1025.             pass
  1026.         self._func = self.default
  1027.  
  1028.     
  1029.     def __getitem__(self, key):
  1030.         if type(key) is type(1):
  1031.             return self.list[key]
  1032.         return self.data[key]
  1033.  
  1034.     
  1035.     def __setitem__(self, key, item):
  1036.         item.parent = weakref.ref(self)
  1037.         self.list.append(item)
  1038.         self.data[key] = item
  1039.  
  1040.     
  1041.     def keys(self):
  1042.         return (map,)((lambda i: self._func(i)), self.list)
  1043.  
  1044.     
  1045.     def items(self):
  1046.         return (map,)((lambda i: (self._func(i), i)), self.list)
  1047.  
  1048.     
  1049.     def values(self):
  1050.         return self.list
  1051.  
  1052.  
  1053.  
  1054. class CollectionNS(UserDict):
  1055.     
  1056.     default = lambda self, k: k.name
  1057.     
  1058.     def __init__(self, parent, key = None):
  1059.         UserDict.__init__(self)
  1060.         self.parent = weakref.ref(parent)
  1061.         self.targetNamespace = None
  1062.         self.list = []
  1063.         if not key:
  1064.             pass
  1065.         self._func = self.default
  1066.  
  1067.     
  1068.     def __getitem__(self, key):
  1069.         self.targetNamespace = self.parent().targetNamespace
  1070.         if type(key) is types.IntType:
  1071.             return self.list[key]
  1072.         if self._CollectionNS__isSequence(key):
  1073.             (nsuri, name) = key
  1074.             return self.data[nsuri][name]
  1075.         return self.data[self.parent().targetNamespace][key]
  1076.  
  1077.     
  1078.     def __setitem__(self, key, item):
  1079.         item.parent = weakref.ref(self)
  1080.         self.list.append(item)
  1081.         targetNamespace = getattr(item, 'targetNamespace', self.parent().targetNamespace)
  1082.         if not self.data.has_key(targetNamespace):
  1083.             self.data[targetNamespace] = { }
  1084.         
  1085.         self.data[targetNamespace][key] = item
  1086.  
  1087.     
  1088.     def __isSequence(self, key):
  1089.         if type(key) in (types.TupleType, types.ListType):
  1090.             pass
  1091.         return len(key) == 2
  1092.  
  1093.     
  1094.     def keys(self):
  1095.         keys = []
  1096.         for None in self.data.keys():
  1097.             tns = None
  1098.         
  1099.         return keys
  1100.  
  1101.     
  1102.     def items(self):
  1103.         return (map,)((lambda i: (self._func(i), i)), self.list)
  1104.  
  1105.     
  1106.     def values(self):
  1107.         return self.list
  1108.  
  1109.  
  1110. from xml.dom.pulldom import PullDOM, START_ELEMENT
  1111.  
  1112. def startPrefixMapping(self, prefix, uri):
  1113.     if not hasattr(self, '_xmlns_attrs'):
  1114.         self._xmlns_attrs = []
  1115.     
  1116.     if not prefix:
  1117.         pass
  1118.     self._xmlns_attrs.append(('xmlns', uri))
  1119.     self._ns_contexts.append(self._current_context.copy())
  1120.     if not prefix:
  1121.         pass
  1122.     self._current_context[uri] = ''
  1123.  
  1124. PullDOM.startPrefixMapping = startPrefixMapping
  1125.  
  1126. def startElementNS(self, name, tagName, attrs):
  1127.     xmlns_uri = 'http://www.w3.org/2000/xmlns/'
  1128.     xmlns_attrs = getattr(self, '_xmlns_attrs', None)
  1129.     if xmlns_attrs is not None:
  1130.         for aname, value in xmlns_attrs:
  1131.             attrs._attrs[(xmlns_uri, aname)] = value
  1132.         
  1133.         self._xmlns_attrs = []
  1134.     
  1135.     (uri, localname) = name
  1136.     if uri:
  1137.         if tagName is None:
  1138.             prefix = self._current_context[uri]
  1139.             if prefix:
  1140.                 tagName = prefix + ':' + localname
  1141.             else:
  1142.                 tagName = localname
  1143.         
  1144.         if self.document:
  1145.             node = self.document.createElementNS(uri, tagName)
  1146.         else:
  1147.             node = self.buildDocument(uri, tagName)
  1148.     elif self.document:
  1149.         node = self.document.createElement(localname)
  1150.     else:
  1151.         node = self.buildDocument(None, localname)
  1152.     for aname, value in attrs.items():
  1153.         (a_uri, a_localname) = aname
  1154.         if a_uri == xmlns_uri:
  1155.             if a_localname == 'xmlns':
  1156.                 qname = a_localname
  1157.             else:
  1158.                 qname = 'xmlns:' + a_localname
  1159.             attr = self.document.createAttributeNS(a_uri, qname)
  1160.             node.setAttributeNodeNS(attr)
  1161.         elif a_uri:
  1162.             prefix = self._current_context[a_uri]
  1163.             if prefix:
  1164.                 qname = prefix + ':' + a_localname
  1165.             else:
  1166.                 qname = a_localname
  1167.             attr = self.document.createAttributeNS(a_uri, qname)
  1168.             node.setAttributeNodeNS(attr)
  1169.         else:
  1170.             attr = self.document.createAttribute(a_localname)
  1171.             node.setAttributeNode(attr)
  1172.         attr.value = value
  1173.     
  1174.     self.lastEvent[1] = [
  1175.         (START_ELEMENT, node),
  1176.         None]
  1177.     self.lastEvent = self.lastEvent[1]
  1178.     self.push(node)
  1179.  
  1180. PullDOM.startElementNS = startElementNS
  1181.  
  1182. def _clone_node(node, deep, newOwnerDocument):
  1183.     if node.ownerDocument.isSameNode(newOwnerDocument):
  1184.         operation = xml.dom.UserDataHandler.NODE_CLONED
  1185.     else:
  1186.         operation = xml.dom.UserDataHandler.NODE_IMPORTED
  1187.     if node.nodeType == xml.dom.minidom.Node.ELEMENT_NODE:
  1188.         clone = newOwnerDocument.createElementNS(node.namespaceURI, node.nodeName)
  1189.         for attr in node.attributes.values():
  1190.             clone.setAttributeNS(attr.namespaceURI, attr.nodeName, attr.value)
  1191.             (prefix, tag) = xml.dom.minidom._nssplit(attr.nodeName)
  1192.             if prefix == 'xmlns':
  1193.                 a = clone.getAttributeNodeNS(attr.namespaceURI, tag)
  1194.             elif prefix:
  1195.                 a = clone.getAttributeNodeNS(attr.namespaceURI, tag)
  1196.             else:
  1197.                 a = clone.getAttributeNodeNS(attr.namespaceURI, attr.nodeName)
  1198.             a.specified = attr.specified
  1199.         
  1200.         if deep:
  1201.             for child in node.childNodes:
  1202.                 c = xml.dom.minidom._clone_node(child, deep, newOwnerDocument)
  1203.                 clone.appendChild(c)
  1204.             
  1205.         
  1206.     elif node.nodeType == xml.dom.minidom.Node.DOCUMENT_FRAGMENT_NODE:
  1207.         clone = newOwnerDocument.createDocumentFragment()
  1208.         if deep:
  1209.             for child in node.childNodes:
  1210.                 c = xml.dom.minidom._clone_node(child, deep, newOwnerDocument)
  1211.                 clone.appendChild(c)
  1212.             
  1213.         
  1214.     elif node.nodeType == xml.dom.minidom.Node.TEXT_NODE:
  1215.         clone = newOwnerDocument.createTextNode(node.data)
  1216.     elif node.nodeType == xml.dom.minidom.Node.CDATA_SECTION_NODE:
  1217.         clone = newOwnerDocument.createCDATASection(node.data)
  1218.     elif node.nodeType == xml.dom.minidom.Node.PROCESSING_INSTRUCTION_NODE:
  1219.         clone = newOwnerDocument.createProcessingInstruction(node.target, node.data)
  1220.     elif node.nodeType == xml.dom.minidom.Node.COMMENT_NODE:
  1221.         clone = newOwnerDocument.createComment(node.data)
  1222.     elif node.nodeType == xml.dom.minidom.Node.ATTRIBUTE_NODE:
  1223.         clone = newOwnerDocument.createAttributeNS(node.namespaceURI, node.nodeName)
  1224.         clone.specified = True
  1225.         clone.value = node.value
  1226.     elif node.nodeType == xml.dom.minidom.Node.DOCUMENT_TYPE_NODE:
  1227.         operation = xml.dom.UserDataHandler.NODE_IMPORTED
  1228.         clone = newOwnerDocument.implementation.createDocumentType(node.name, node.publicId, node.systemId)
  1229.         clone.ownerDocument = newOwnerDocument
  1230.         if deep:
  1231.             clone.entities._seq = []
  1232.             clone.notations._seq = []
  1233.             for n in node.notations._seq:
  1234.                 notation = xml.dom.minidom.Notation(n.nodeName, n.publicId, n.systemId)
  1235.                 notation.ownerDocument = newOwnerDocument
  1236.                 clone.notations._seq.append(notation)
  1237.                 if hasattr(n, '_call_user_data_handler'):
  1238.                     n._call_user_data_handler(operation, n, notation)
  1239.                     continue
  1240.             
  1241.             for e in node.entities._seq:
  1242.                 entity = xml.dom.minidom.Entity(e.nodeName, e.publicId, e.systemId, e.notationName)
  1243.                 entity.actualEncoding = e.actualEncoding
  1244.                 entity.encoding = e.encoding
  1245.                 entity.version = e.version
  1246.                 entity.ownerDocument = newOwnerDocument
  1247.                 clone.entities._seq.append(entity)
  1248.                 if hasattr(e, '_call_user_data_handler'):
  1249.                     e._call_user_data_handler(operation, n, entity)
  1250.                     continue
  1251.             
  1252.         
  1253.     else:
  1254.         raise xml.dom.NotSupportedErr('Cannot clone node %s' % repr(node))
  1255.     if node.nodeType == xml.dom.minidom.Node.ELEMENT_NODE(node, '_call_user_data_handler'):
  1256.         node._call_user_data_handler(operation, node, clone)
  1257.     
  1258.     return clone
  1259.  
  1260. xml.dom.minidom._clone_node = _clone_node
  1261.