
f#]c           @   s<  d  Z  d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l	 m
 Z
 d d l m Z e j e  Z e j j d d d f  a d   Z d	   Z d
   Z d d  Z d d  Z e e j j d  Z e j j d  Z e e e d  Z d   Z  d   Z! d e" f d     YZ# d S(   sG   Functions that support activities related to the Document Object Model.iN(   t   six(   t   xranget   cores   2.0t   xmlc           C   s   t  S(   sW  Return the DOMImplementation object used for pyxb operations.

    This is primarily used as the default implementation when generating DOM
    trees from a binding instance.  It defaults to whatever
    xml.dom.getDOMImplementation() returns in your installation (often
    xml.dom.minidom).  It can be overridden with SetDOMImplementation().(   t   __DOMImplementation(    (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   GetDOMImplementation%   s    	c         C   s
   |  a  t  S(   s.   Override the default DOMImplementation object.(   R   (   t   dom_implementation(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   SetDOMImplementation0   s    c         K   s   |  } t  j t  j k r t  j j j   } t j r[ t | t j	  r[ | j
 t  j  } n0 t j r t | t j	  r | j t  j  } n  t j j j | |  St  j j j |  |  S(   sB   Convert string to a DOM instance.

    @see: L{pyxb._SetXMLStyle}.(   t   pyxbt   XMLStyle_minidomt	   _XMLStylet   utilst   saxutilst   make_parserR    t   PY2t
   isinstancet   binary_typet   encodet   _InputEncodingt   PY3t   decodeR   t   domt   minidomt   parseStringt   saxdom(   t   xml_textt   kwt   xmltt   parser(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   StringToDOM9   s    c         C   sS   | } t  | t j j  r* | j   } n  |  j | |  } | d k rL d S| j S(   sy  Namespace-aware search for an optional attribute in a node.

    @param attribute_ncname: The local name of the attribute.
    @type attribute_ncname: C{str} or C{unicode}

    @keyword attribute_ns: The namespace of the attribute.  Defaults to None
    since most attributes are not in a namespace.  Can be provided as either a
    L{pyxb.namespace.Namespace} instance, or a string URI.
    @type attribute_ns: C{None} or C{str} or C{unicode} or L{pyxb.namespace.Namespace}

    @return: The value of the attribute, or C{None} if the attribute is not
    present.  (Unless C{None}, the value will always be a (unicode) string.)
    N(   R   R   t	   namespacet	   Namespacet   urit   getAttributeNodeNSt   Nonet   value(   t   nodet   attribute_ncnamet   attribute_nst   ns_urit   attr(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   NodeAttributeJ   s    c         C   sD   t  |  | |  } | d k r" d St j j j |   } | j |  S(   s  Like L{NodeAttribute} but where the content is a QName that must be
    resolved in the context of the node.

    @param attribute_ncname: as in L{NodeAttribute}
    @keyword attribute_ns: as in L{NodeAttribute}

    @return: The expanded name to which the value of the attribute resolves
    given current namespaces, or C{None} if the attribute is not present
    @rtype: L{pyxb.namespace.ExpandedName}
    N(   R)   R"   R   R   t   NamespaceContextt   GetNodeContextt   interpretQName(   R$   R%   R&   R(   t   nsc(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   NodeAttributeQNamea   s
    c         C   s   d } xi |  j D]^ } t j j j | j k r | j | |  r | re t j	 d | |  j
 f   n  | } q q W| d k r | r t j	 d | |  j
 f   n  | S(   s  Locate a unique child of the DOM node.

    This function returns the sole child of node which is an ELEMENT_NODE
    instance and has a tag consistent with the given tag.  If multiple nodes
    with a matching C{tag} are found, or C{absent_ok} is C{False} and no
    matching tag is found, an exception is raised.

    @param node: An a xml.dom.Node ELEMENT_NODE instance
    @param tag: the NCName of an element in the namespace
    @keyword absent_ok: If C{True} (default), C{None} is returned if no match
    can be found.  If C{False}, an exception is raised if no match can be
    found.
    @keyword namespace: The namespace to which the child element belongs.
    Default is the XMLSchema namespace.
    @rtype: C{xml.dom.Node}

    @raise pyxb.SchemaValidationError: multiple elements are identified
    @raise pyxb.SchemaValidationError: C{absent_ok} is C{False} and no element is identified.
    s!   Multiple %s elements nested in %ss!   Expected %s elements nested in %sN(   R"   t
   childNodesR   R   t   Nodet   ELEMENT_NODEt   nodeTypet   nodeIsNamedR   t   SchemaValidationErrort   nodeName(   R$   t   tagt	   absent_okR   t	   candidatet   cn(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   LocateUniqueChildr   s    *c         C   sX   g  } xK |  j  D]@ } t j j j | j k r | j | |  r | j |  q q W| S(   s  Locate all children of the DOM node that have a particular tag.

    This function returns a list of children of node which are ELEMENT_NODE
    instances and have a tag consistent with the given tag.

    @param node: An a xml.dom.Node ELEMENT_NODE instance.
    @param tag: the NCName of an element in the namespace, which defaults to the
    XMLSchema namespace.
    @keyword namespace: The namespace to which the child element belongs.
    Default is the XMLSchema namespace.

    @rtype: C{list(xml.dom.Node)}
    (   R/   R   R   R0   R1   R2   R3   t   append(   R$   R6   R   t   matchesR9   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   LocateMatchingChildren   s
    *c         C   s   d } x |  j D]z } t j j j | j k r | rR t j j	 j
 | d  rR q n  | r | rz t j d |  j f   n  | } q | Sq q W| d k r | r t j d |  j f   n  | S(   so  Locate the first element child of the node.


    @param node: An a xml.dom.Node ELEMENT_NODE instance.
    @keyword absent_ok: If C{True} (default), C{None} is returned if no match
    can be found.  If C{False}, an exception is raised if no match can be
    found.
    @keyword require_unique: If C{False} (default), it is acceptable for there
    to be multiple child elements.  If C{True}, presence of multiple child
    elements raises an exception.
    @keyword ignore_annotations: If C{True} (default), annotations are skipped
    wheen looking for the first child element.  If C{False}, an annotation
    counts as an element.
    @rtype: C{xml.dom.Node}

    @raise SchemaValidationError: C{absent_ok} is C{False} and no child
    element was identified.
    @raise SchemaValidationError: C{require_unique} is C{True} and multiple
    child elements were identified
    t
   annotations   Multiple elements nested in %ss   No elements nested in %sN(   R"   R/   R   R   R0   R1   R2   R   R   t	   XMLSchemaR3   R4   R5   (   R$   R7   t   require_uniquet   ignore_annotationsR8   R9   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   LocateFirstChildElement   s    	c         C   sM   xF |  j  D]; } t j j j | j k r
 t j j j	 | d  r
 t
 Sq
 Wt S(   sy   Return True iff C{node} has an ELEMENT_NODE child that is not an
    XMLSchema annotation node.

    @rtype: C{bool}
    R>   (   R/   R   R   R0   R1   R2   R   R   R?   R3   t   Truet   False(   R$   R9   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   HasNonAnnotationChild   s    1c         C   s   g  } x |  j  D] } t j j j | j k rA | j | j  q t j j j | j k rl | j | j  q t j j j	 | j k r q t
 j |   q Wd t |  k r d Sd j |  S(   s8  Walk all the children, extracting all text content and
    catenating it into the return value.

    Returns C{None} if no text content (including whitespace) is found.

    This is mainly used to strip comments out of the content of complex
    elements with simple types.

    @rtype: C{unicode} or C{str}
    i    t    N(   R/   R   R   R0   t	   TEXT_NODER2   R;   t   datat   CDATA_SECTION_NODEt   COMMENT_NODER   t   NonElementValidationErrort   lenR"   t   join(   R$   t   textR9   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   ExtractTextContent   s    t   BindingDOMSupportc           B   sL  e  Z d  Z d   Z d Z d   Z d Z d   Z d Z	 d   Z
 e d    Z d d e d d  Z e j j   Z d Z d Z d   Z e d    Z d	   Z e d
    Z d d  Z e d d   Z e d  Z e d  Z e d  Z d   Z d d  Z  d   Z! d d  Z" d   Z# d   Z$ d   Z% d   Z& d   Z' RS(   s_   This holds DOM-related information used when generating a DOM tree from
    a binding instance.c         C   s   |  j  S(   s   The DOMImplementation object to be used.

        Defaults to L{pyxb.utils.domutils.GetDOMImplementation()}, but can be
        overridden in the constructor call using the C{implementation}
        keyword.(   t"   _BindingDOMSupport__implementation(   t   self(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   implementation   s    c         C   s   |  j  S(   s2   Return the document generated using this instance.(   t   _BindingDOMSupport__document(   RR   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   document   s    c         C   s   |  j  S(   s;  Indicates whether {xsi:type<http://www.w3.org/TR/xmlschema-1/#xsi_type>} should be added to all elements.

        Certain WSDL styles and encodings seem to require explicit notation of
        the type of each element, even if it was specified in the schema.

        This value can only be set in the constructor.(   t"   _BindingDOMSupport__requireXSIType(   RR   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   requireXSIType   s    c         C   sT   |  j    j d d d  |  _ |  j j   |  j j t j j	 d  t
   |  _ d S(   s7  Reset this instance to the state it was when created.

        This creates a new root document with no content, resets the
        namespace-prefix map to its as-constructed content, and clears the set
        of referenced namespace prefixes.  The defaultNamespace and
        requireXSIType are not modified.t   xsiN(   RS   t   createDocumentR"   RT   t$   _BindingDOMSupport__namespaceContextt   resett   declareNamespaceR   R   t   XMLSchema_instancet   sett/   _BindingDOMSupport__referencedNamespacePrefixes(   RR   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyR[   	  s    c         C   s   |  j  j   d S(   sC   Reset the global defaults for default/prefix/namespace information.N(   t$   _BindingDOMSupport__NamespaceContextR[   (   t   cls(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   Reset  s    c         C   sx   | d k r t   } n  | |  _ | |  _ t j j d |  j d |  |  _ | d k	 rj |  j j	 |  n  |  j
   d S(   sF  Create a new instance used for building a single document.

        @keyword implementation: The C{xml.dom} implementation to use.
        Defaults to the one selected by L{GetDOMImplementation}.

        @keyword default_namespace: The namespace to configure as the default
        for the document.  If not provided, there is no default namespace.
        @type default_namespace: L{pyxb.namespace.Namespace}

        @keyword require_xsi_type: If C{True}, an U{xsi:type
        <http://www.w3.org/TR/xmlschema-1/#xsi_type>} attribute should be
        placed in every element.
        @type require_xsi_type: C{bool}

        @keyword namespace_prefix_map: A map from pyxb.namespace.Namespace
        instances to the preferred prefix to use for the namespace in xmlns
        declarations.  The default one assigns 'xsi' for the XMLSchema
        instance namespace.
        @type namespace_prefix_map: C{map} from L{pyxb.namespace.Namespace} to C{str}

        @raise pyxb.LogicError: the same prefix is associated with multiple
        namespaces in the C{namespace_prefix_map}.

        t   parent_contextt   in_scope_namespacesN(   R"   R   RQ   RV   R   R   R*   R`   RZ   t   setDefaultNamespaceR[   (   RR   RS   t   default_namespacet   require_xsi_typet   namespace_prefix_map(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   __init__  s    		c         C   s   |  j  j   S(   s'   The default namespace for this instance(   RZ   t   defaultNamespace(   RR   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyRj   K  s    c         C   s   |  j  j   S(   sJ   The global default namespace (used on instance creation if not overridden)(   R`   Rj   (   Ra   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   DefaultNamespaceN  s    c         C   s   |  j  j |  S(   N(   RZ   Re   (   RR   Rf   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyRe   S  s    c         C   s   |  j  j |  S(   N(   R`   Re   (   Ra   Rf   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   SetDefaultNamespaceU  s    c         C   s   |  j  j | |  S(   s.   Declare a namespace within this instance only.(   RZ   R\   (   RR   R   t   prefix(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyR\   Y  s    c         C   s   |  j  j | |  S(   sF   Declare a namespace that will made available to each created instance.(   R`   R\   (   Ra   R   Rm   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   DeclareNamespace\  s    c         C   s   | d k s | j   r d St | t j  rI t j j | d t } n  |  j	   | k re | re d S|  j
 j |  } | d k r |  j
 j |  } n  |  j j | | f  | S(   s
  Return the prefix to be used for the given namespace.

        This will L{declare <declareNamespace>} the namespace if it has not
        yet been observed.  It will also ensure the mapping from the returned
        prefix to C{namespace} is recorded for addition as an xmlns directive
        in the final document.

        @param namespace: The namespace for which a prefix is needed.  If the
        provided namespace is C{None} or an absent namespace, the C{None}
        value will be returned as the corresponding prefix.

        @keyword enable_default_namespace: Normally if the namespace is the default
        namespace C{None} is returned to indicate this.  If this keyword is
        C{False} then we need a namespace prefix even if this is the default.
        t   create_if_missingN(   R"   t   isAbsentNamespaceR   R    t   string_typesR   R   t   NamespaceForURIRC   Rj   RZ   t   prefixForNamespaceR\   R_   t   add(   RR   R   t   enable_default_namespacet   pfx(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   namespacePrefixa  s    c         C   se   t  | t j j  s t  | j   } |  j | j   d | } | d  k	 ra d | | f } n  | S(   NRu   s   %s:%s(   R   R   R   t   ExpandedNamet   AssertionErrort	   localNameRw   R"   (   RR   t   qnameRu   t   nameRm   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   qnameAsText}  s    c         C   s   d d l  m } m } t | t j j  r> |  j | d | St | |  r| d j g  | D] } |  j	 | d | ^ qZ  St | |  r | j
   S| d k	 s t  t j |  S(   s1  Represent a simple type value as XML text.

        This is essentially what C{value.xsdLiteral()} does, but this one
        handles any special cases such as QName values where the lexical
        representation cannot be done in isolation of external information
        such as namespace declarations.i(   t   simpleTypeDefinitiont   STD_listRu   t    N(   t   pyxb.binding.basisR~   R   R   R   R   Rx   R}   RM   t   valueAsTextt
   xsdLiteralR"   Ry   R    t	   text_type(   RR   R#   Ru   R~   R   t   _v(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyR     s    /
c         C   sk   | } t  j j } t | t j j  rK | j   } |  j | d t	 } n  | j
 | | |  j |   d S(   s  Add an attribute to the given element.

        @param element: The element to which the attribute should be added
        @type element: C{xml.dom.Element}
        @param expanded_name: The name of the attribute.  This may be a local
        name if the attribute is not in a namespace.
        @type expanded_name: L{pyxb.namespace.Namespace} or C{str} or C{unicode}
        @param value: The value of the attribute
        @type value: C{str} or C{unicode}
        Ru   N(   R   R   t   EMPTY_NAMESPACER   R   R   Rx   t   namespaceURIR}   RD   t   setAttributeNSR   (   RR   t   elementt   expanded_nameR#   R|   R'   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   addAttribute  s    c         C   s   t  | t j j  s' t j d   n  | j   rE t j d   n  | d k rc |  j |  } n  | sr d } n
 d | } | j t j j	 j
   | | j
    | S(   s  Manually add an XMLNS declaration to the document element.

        @param namespace: a L{pyxb.namespace.Namespace} instance

        @param prefix: the prefix by which the namespace is known.  If
        C{None}, the default prefix as previously declared will be used; if
        C{''} (empty string) a declaration for C{namespace} as the default
        namespace will be generated.

        @return: C{prefix} as used in the added declaration.
        s7   addXMLNSdeclaration: must be given a namespace instances>   addXMLNSdeclaration: namespace must not be an absent namespacet   xmlnss   xmlns:N(   R   R   R   R   t
   UsageErrorRp   R"   Rw   R   t   XMLNamespacesR    (   RR   R   R   Rm   t   an(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   addXMLNSDeclaration  s    	
%c         C   sw   |  j    } | d k	 r7 |  j |  j   j | d  n  x3 |  j D]( \ } } |  j |  j   j | |  qA W|  j   S(   s  Do the final cleanup after generating the tree.  This makes sure
        that the document element includes XML Namespace declarations for all
        namespaces referenced in the tree.

        @return: The document that has been created.
        @rtype: C{xml.dom.Document}RF   N(   Rj   R"   R   RU   t   documentElementR_   (   RR   t   nsRv   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   finalize  s     c         C   s  | d k r |  j   j } n  | d k r6 |  j } n  t | t j  r` t j j	 d |  } n  t | t j j	  s t j
 d t |  f   n  | j   } t j j } | j   } | d k	 r | j   } |  j |  } n  |  j j | |  } | j |  S(   s'  Create a new element node in the tree.

        @param expanded_name: The name of the element.  A plain string
        indicates a name in no namespace.
        @type expanded_name: L{pyxb.namespace.ExpandedName} or C{str} or C{unicode}

        @keyword parent: The node in the tree that will serve as the child's
        parent.  If C{None}, the document element is used.  (If there is no
        document element, then this call creates it as a side-effect.)

        @return: A newly created DOM element
        @rtype: C{xml.dom.Element}
        s!   Invalid type %s for expanded nameN(   R"   RU   R   RT   R   R    Rq   R   R   Rx   t
   LogicErrort   typeR   R   R   Rz   R    R}   t   createElementNSt   appendChild(   RR   R   t   parentR   R'   R|   R   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   createChildElement  s     c         C   sT  d } | j d k	 r3 t j j | j d t } n  | j | j k rQ | j } nP | j	 | j k r | j
 } t | t  r | d } q n t j d | f   d } | } d | j d  k  r | j d d  \ } } | d k r t j d   q n  d } | } | d k	 rJ| j   } |  j | |  |  j | j |   } n  | | f S(   s  Convert namespace information from a DOM node to text for new DOM node.

        The namespaceURI and nodeName are extracted and parsed.  The namespace
        (if any) is registered within the document, along with any prefix from
        the node name.  A pair is returned where the first element is the
        namespace URI or C{None}, and the second is a QName to be used for the
        expanded name within this document.

        @param node: An xml.dom.Node instance, presumably from a wildcard match.
        @rtype: C{( str, str )}Ro   i   s)   Unable to determine name from DOM node %si    t   :s,   QName with prefix but no available namespaceN(   R"   R   R   R   Rr   RC   R1   R2   t   tagNamet   ATTRIBUTE_NODER|   R   t   tupleR   t   findt   splitR   R    R\   R}   t   createExpandedName(   RR   R$   R   R|   Rv   t
   local_nameR'   t	   node_name(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   _makeURINodeNamePair  s.    	c   	      C   sO  | j  | j k r |  j |  \ } } | j | |  } | j } x9 t | j  D]( } | j |  j | j	 |  |   qR Wx* | j
 D] } | j |  j | |   q W| S| j | j k r | j | j  S| j | j k r|  j |  \ } } | j | |  } | j | _ | S| j | j k r<| j | j  St d |   d  S(   Ns   DOM node not supported in clone(   R1   R2   R   R   t
   attributesR   t   lengtht   setAttributeNodeNSt
   _deepClonet   itemR/   R   RG   t   createTextNodeRH   R   t   createAttributeNSR#   RJ   t   createCommentt
   ValueError(	   RR   R$   t   docnodeR'   R   t
   clone_nodet   attrst   ait   child(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyR     s&    	&c         C   s+   |  j    j d d d  } |  j | |  S(   s   Create a deep copy of the node in the target implementation.

        Used when converting a DOM instance from one implementation (e.g.,
        L{pyxb.utils.saxdom}) into another (e.g., L{xml.dom.minidom}).N(   RS   RY   R"   R   (   RR   R$   t   new_doc(    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   cloneIntoImplementation+  s    c         C   sF   t  | t j j j t j j j f  r9 |  j |  } n  | j	 |  S(   s  Add the child to the parent.

        @note: If the child and the parent use different DOM implementations,
        this operation will clone the child into a new instance, and give that
        to the parent.

        @param child: The value to be appended
        @type child: C{xml.dom.Node}
        @param parent: The new parent of the child
        @type parent: C{xml.dom.Node}
        @rtype: C{xml.dom.Node}(
   R   R   R   R   R0   R   R   R   R   R   (   RR   R   R   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyR   3  s    'c         C   s%   | j  |  j   j |  j |    S(   s*   Add the text to the parent as a text node.(   R   RU   R   R   (   RR   RN   R   (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   appendTextChildF  s    N((   t   __name__t
   __module__t   __doc__RS   R"   RQ   RU   RT   RW   RV   R[   t   classmethodRb   RD   Ri   R   R   R*   R`   RZ   R_   Rj   Rk   Re   Rl   R\   Rn   RC   Rw   R}   R   R   R   R   R   R   R   R   R   R   (    (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyRP      s@   				$				 	&			(   s   cores   2.0(   s   xmls   2.0($   R   t   loggingt   xml.domR   R   t   pyxb.namespacet   pyxb.namespace.resolutiont   pyxb.utils.saxutilst   pyxb.utils.saxdomt
   pyxb.utilsR    t   pyxb.utils.six.movesR   t	   getLoggerR   t   _logR   t   getDOMImplementationR"   R   R   R   R   R)   R.   RC   R   R?   R:   R=   RD   RB   RE   RO   t   objectRP   (    (    (    sH   /data/av2000/b2b/venv/lib/python2.7/site-packages/pyxb/utils/domutils.pyt   <module>   s,   				%		