관리-도구
편집 파일: xmltodict.cpython-38.pyc
U )�e�J � @ sF d Z zddlmZ W n ek r4 ddlmZ Y nX ddlmZ ddlm Z zddl m Z W nF ek r� zddl m Z W n ek r� ddl m Z Y nX Y nX e ZddlZeeee�� dd� ��d k r�dd lmZ dd lmZ zeZW n ek �r eZY nX ze Z W n ek �r. eZ Y nX d Z d Z dZ G dd� de!�Z"G dd� de#�Z$deddddfdd�Z%d(dd�Z&d)d d �Z'd*d!d"�Z(e)d#k�rBddl*Z*ddl+Z+ze*j,j-Z,e*j.j-Z.W n" e/k �r� e*j,Z,e*j.Z.Y nX e*j0d$d� \Z1ee1�Z1d%d&� Z2z(e%e,e1e2e d'�Z3e1dk�r(e2g e3� W n e4k �r@ Y nX dS )+z:Makes working with XML feel like you are working with JSON� )�pyexpat)�expat)� XMLGenerator)�AttributesImpl)�StringION� )� � )� OrderedDict)� isgeneratorz Martin Blechz0.13.0�MITc @ s e Zd ZdS )�ParsingInterruptedN)�__name__� __module__� __qualname__� r r �7/opt/hc_python/lib/python3.8/site-packages/xmltodict.pyr ' s r c @ s~ e Zd Zddd� dddddd edd d d d fd d �Zdd� Zdd� Zdd� Zdd� Zdd� Z dd� Z dd� Z d d � Z d d � Z d S ) �_DictSAXHandlerr c G s dS �NTr )�argsr r r �<lambda>. � z_DictSAXHandler.<lambda>T�@�#textF� N�:z#commentc C sx g | _ g | _g | _d | _|| _|| _|| _|| _|| _|| _ || _ || _ | | _ | | _ | | _| | _| � | _| | _|| _d S �N)�path�stack�data�item� item_depth� xml_attribs� item_callback� attr_prefix� cdata_key� force_cdata�cdata_separator� postprocessor�dict_constructor�strip_whitespace�namespace_separator� namespaces�namespace_declarations� force_list� comment_key)�selfr! r# r" r$ r% r& r' r( r) r* r+ r, r. r/ r r r �__init__, s& z_DictSAXHandler.__init__c C s� | j d kr|S |�| j�}|dkr&|S |d |� ||d d � }}z| j | }W n tk rj |}Y nX |st|S | j�||f�S d S )N���� )r, �rfindr+ �KeyError�join)r0 � full_name�i� namespace�nameZshort_namespacer r r � _build_nameO s z_DictSAXHandler._build_namec C s2 t |t�r|S | �t|dd d� |dd d� ��S )Nr r r3 )� isinstance�dictr) �zip)r0 �attrsr r r �_attrs_to_dict_ s z _DictSAXHandler._attrs_to_dictc C s || j |p d< d S )Nr )r- )r0 �prefix�urir r r �startNamespaceDecld s z"_DictSAXHandler.startNamespaceDeclc C s� | � |�}| �|�}|r2| jr2| j|d< | �� | _| j�||p@d f� t| j�| jkr�| j�| j | j f� | j r�g }|� � D ]F\}}| j | � |� }| jr�| �| j||�}n||f}|r||�|� q|| �|�}nd }|p�d | _ g | _ d S )NZxmlns)r; r@ r- r) r �append�lenr! r r r r" �itemsr$ r( )r0 r7 r? r: Z attr_entries�key�value�entryr r r � startElementg s* z _DictSAXHandler.startElementc C s | � |�}t| j�| jkrX| j}|d kr@| js2d n | j�| j�}| �| j|�}|sXt � �| j �r| jsjd n | j�| j�}| j}| j � � \| _| _| j r�|r�|� � p�d }|r�| jr�|d kr�| �� }|d k r�|r�| �|| j|� | �| j||�| _n| �| j||�| _n d | _g | _| j� � d S r )r; rE r r! r r r' r6 r# r r �popr* �stripr& r) � push_datar% )r0 r7 r: r Zshould_continuer r r r � endElement� s8 � � z_DictSAXHandler.endElementc C s | j s|g| _ n | j �|� d S r )r rD �r0 r r r r � characters� s z_DictSAXHandler.charactersc C s& | j r|�� }| �| j| j|�| _d S r )r* rL rM r r/ rO r r r �comments� s z_DictSAXHandler.commentsc C s� | j d k r.| � | j||�}|d kr&|S |\}}|d kr>| �� }z.|| }t|t�r^|�|� n ||g||< W n4 tk r� | �||�r�|g||< n|||< Y nX |S r )r( r r) r< �listrD r5 �_should_force_list)r0 r rG r �resultrH r r r rM � s" z_DictSAXHandler.push_datac C sZ | j s dS t| j t�r | j S z || j kW S tk rT | � | jd d� ||� Y S X d S )NFr2 )r. r< �bool� TypeErrorr )r0 rG rH r r r rS � s z"_DictSAXHandler._should_force_list)r r r �_dictr1 r; r@ rC rJ rN rP rQ rM rS r r r r r + s0 � # r Fr Tc K s. t f d|i|��}t| t�r.|s$d}| �|�} |s6d}|�||�} z d| _W n tk r` Y nX |j| _|j | _ |j | _ |j | _|r�|j| _d| _|r�zd} | j�| d� W n( tk r� dd� | _dd� | _Y nX t| d �r�| �| � n:t| ��r | D ]} | �| d � q�| �d d� n | �| d� |jS ) a Parse the given XML input and convert it into a dictionary. `xml_input` can either be a `string`, a file-like object, or a generator of strings. If `xml_attribs` is `True`, element attributes are put in the dictionary among regular child elements, using `@` as a prefix to avoid collisions. If set to `False`, they are just ignored. Simple example:: >>> import xmltodict >>> doc = xmltodict.parse(""" ... <a prop="x"> ... <b>1</b> ... <b>2</b> ... </a> ... """) >>> doc['a']['@prop'] u'x' >>> doc['a']['b'] [u'1', u'2'] If `item_depth` is `0`, the function returns a dictionary for the root element (default behavior). Otherwise, it calls `item_callback` every time an item at the specified depth is found and returns `None` in the end (streaming mode). The callback function receives two parameters: the `path` from the document root to the item (name-attribs pairs), and the `item` (dict). If the callback's return value is false-ish, parsing will be stopped with the :class:`ParsingInterrupted` exception. Streaming example:: >>> def handle(path, item): ... print('path:%s item:%s' % (path, item)) ... return True ... >>> xmltodict.parse(""" ... <a prop="x"> ... <b>1</b> ... <b>2</b> ... </a>""", item_depth=2, item_callback=handle) path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:1 path:[(u'a', {u'prop': u'x'}), (u'b', None)] item:2 The optional argument `postprocessor` is a function that takes `path`, `key` and `value` as positional arguments and returns a new `(key, value)` pair where both `key` and `value` may have changed. Usage example:: >>> def postprocessor(path, key, value): ... try: ... return key + ':int', int(value) ... except (ValueError, TypeError): ... return key, value >>> xmltodict.parse('<a><b>1</b><b>2</b><b>x</b></a>', ... postprocessor=postprocessor) {'a': {'b:int': [1, 2], 'b': 'x'}} You can pass an alternate version of `expat` (such as `defusedexpat`) by using the `expat` parameter. E.g: >>> import defusedexpat >>> xmltodict.parse('<a>hello</a>', expat=defusedexpat.pyexpat) {'a': 'hello'} You can use the force_list argument to force lists to be created even when there is only a single child of a given level of hierarchy. The force_list argument is a tuple of keys. If the key for a given level of hierarchy is in the force_list argument, that level of hierarchy will have a list as a child (even if there is only one sub-element). The index_keys operation takes precedence over this. This is applied after any user-supplied postprocessor has already run. For example, given this input: <servers> <server> <name>host1</name> <os>Linux</os> <interfaces> <interface> <name>em0</name> <ip_address>10.0.0.1</ip_address> </interface> </interfaces> </server> </servers> If called with force_list=('interface',), it will produce this dictionary: {'servers': {'server': {'name': 'host1', 'os': 'Linux'}, 'interfaces': {'interface': [ {'name': 'em0', 'ip_address': '10.0.0.1' } ] } } } `force_list` can also be a callable that receives `path`, `key` and `value`. This is helpful in cases where the logic that decides whether a list should be forced is more complex. If `process_comment` is `True` then comment will be added with comment_key (default=`'#comment'`) to then tag which contains comment For example, given this input: <a> <b> <!-- b comment --> <c> <!-- c comment --> 1 </c> <d>2</d> </b> </a> If called with process_comment=True, it will produce this dictionary: 'a': { 'b': { '#comment': 'b comment', 'c': { '#comment': 'c comment', '#text': '1', }, 'd': '2', }, } r+ �utf-8NTz4http://apache.org/xml/features/disallow-doctype-declc S s d S r r ��xr r r r p r zparse.<locals>.<lambda>c W s dS )Nr3 r rY r r r r r r �readFr )r r< �_unicode�encode� ParserCreate�ordered_attributes�AttributeErrorrC �StartNamespaceDeclHandlerrJ �StartElementHandlerrN �EndElementHandlerrP �CharacterDataHandlerrQ �CommentHandler� buffer_text�_readerZ setFeature�DefaultHandler�ExternalEntityRefHandler�hasattr� ParseFiler �Parser ) Z xml_input�encodingr Zprocess_namespacesr+ Zdisable_entitiesZprocess_comments�kwargs�handler�parser�feature�chunkr r r �parse� sP � � rs r c C sl |s| S z| � |d�\}} W n tk r0 Y n8X |�|�|��}|rdd�|�|�rX|nd||| �n| } | S )Nr3 z{}{}{}{}r )�rsplit� ValueError�getrL �format� startswith)r: r, Zns_sepr$ �nsZns_resr r r �_process_namespace~ s" � ��rz r � � c C s� t | | | |�} |d k r4|| |�}|d kr,d S |\} }t|d�rRt|t�sRt|t�rX|g}t|�D �]@\}}| r�|dkr�|dkr�td��|d kr�t� }n\t|t�r�|r�t d�}q�t d�}n:t|t�s�| r�t|d�r�t|t�s�t| |ff�}nt |�}t|t��r t||ff�}d }t� }g }|� � D ]�\}}||k�r<|}�q"|� |��r�t || | |�}|dk�r�t|t��r�|� � D ]0\}}d� |�r�d� |�nd �}t |�||< �qt�q"t|t ��s�t |�}|||t |�d � < �q"|�||f� �q"|�r�|�|| � |�| t|�� |�r"|�r"|�|� |D ]0\}}t||||||d |||| | | | d � �q&|d k �rl|�|� |�r�|�r�|�|| � |�| � |r`|r`|�|� q`d S ) N�__iter__r z document with multiple roots�true�falsez@xmlnszxmlns{}z:{}r r3 )r, r+ � expand_iter)rz rj r< � _basestringr= � enumerateru rW rU r\ rF rx rw rE rD ZignorableWhitespacerJ r �_emitrP rN )rG rH �content_handlerr$ r% �depth� preprocessor�prettyZnewl�indentr+ r, � full_documentr� rT �index�v�cdatar? �children�ikZiv�k�attrZ child_keyZ child_valuer r r r� � s� �� � � r� rX c K s� |rt | �dkrtd��d}|dkr.t� }d}|r@t||d�}n t||�}|rV|�� | �� D ] \}} t|| |fd|i|�� q^|r�|�� |r�|�� } z| � |�} W n t k r� Y nX | S dS )ax Emit an XML document for the given `input_dict` (reverse of `parse`). The resulting XML document is returned as a string, but if `output` (a file-like object) is specified, it is written there instead. Dictionary keys prefixed with `attr_prefix` (default=`'@'`) are interpreted as XML node attributes, whereas keys equal to `cdata_key` (default=`'#text'`) are treated as character data. The `pretty` parameter (default=`False`) enables pretty-printing. In this mode, lines are terminated with `' '` and indented with `' '`, but this can be customized with the `newl` and `indent` parameters. r3 z$Document must have exactly one root.FNTr� ) rE ru r r Z startDocumentrF r� Z endDocument�getvalue�decoder` ) Z input_dict�outputrm r� Zshort_empty_elementsrn Z must_returnr� rG rH r r r �unparse� s0 �r� �__main__r3 c C s t �| |ft� dS r )�marshal�dump�stdout)r r r r r � handle_item s r� )r! r# r) )r r ) r r r NFr{ r| r NTN)NrX TF)5�__doc__Z defusedexpatr r � ImportError� xml.parsersZxml.sax.saxutilsr Zxml.sax.xmlreaderr � cStringIOr �ior= rW �platform�tuple�map�int�python_version_tuple� collectionsr �inspectr � basestringr� � NameError�str�unicoder\ � __author__� __version__� __license__� Exceptionr �objectr rs rz r� r� r �sysr� �stdin�bufferr� r` �argvr! r� �root�KeyboardInterruptr r r r �<module> s� � 5 � O � + �