python xml dom help please

[deglog]

Apologies if this post appears more than once.

The file -

---------------
<?xml version="1.0" encoding="utf-8"?>
<Game><A/><B/><C/></Game>
---------------

is processed by this program -

---------------
#!/usr/bin/env python

from xml.dom.ext.reader import PyExpat
from xml.dom.ext import PrettyPrint

import sys

def deepen(nodeList):
for node in nodeList:
print(node.nodeName)
if node.previousSibling != None:
if node.previousSibling.nodeType == node.ELEMENT_NODE:
if node.previousSibling.hasChildNodes():
print("has children")
node.previousSibling.lastChild.appendChild(node)
else:
node.previousSibling.appendChild(node)
deepen(node.childNodes)

# get DOM object
reader = PyExpat.Reader()
doc = reader.fromUri(sys.argv[1])

# call func
deepen(doc.childNodes)

# display altered document
PrettyPrint(doc)
---------------

which outputs the following -

---------------
Game
Game
A
B
<?xml version='1.0' encoding='UTF-8'?>
<Game>
<A>
<B/>
</A>
<C/>
</Game>

---------------

Can anybody explain why the line 'print(node.nodeName)' never prints 'C'?

Also, why 'has children' is never printed?

I am trying to output

---------------
<?xml version='1.0' encoding='UTF-8'?>
<Game>
<A>
<B>
<C/>
</B>
</A>
</Game>
---------------

I know there are easier ways to do this, but i want to do it using dom.

Thanks in advance.

[Miklós]

Without having any thorough look at your (recursive)'deepen' function, I can
see there's no termination condition for the recursion....
So that's one reason this won't work the way you want it to.

Miklós
deglog <sp***********@ntlworld.com> wrote in message
news:f7*************************@posting.google.co m...

---------------
#!/usr/bin/env python

from xml.dom.ext.reader import PyExpat
from xml.dom.ext import PrettyPrint

import sys

def deepen(nodeList):
for node in nodeList:
print(node.nodeName)
if node.previousSibling != None:
if node.previousSibling.nodeType == node.ELEMENT_NODE:
if node.previousSibling.hasChildNodes():
print("has children")
node.previousSibling.lastChild.appendChild(node)
else:
node.previousSibling.appendChild(node)
deepen(node.childNodes)

[Diez B. Roggisch]

Miklós wrote:

Without having any thorough look at your (recursive)'deepen' function, I
can see there's no termination condition for the recursion....
So that's one reason this won't work the way you want it to.

Nope - he has a termination condition. deepen is called for all childNodes,
so he makes a traversal of all nodes.

Regards,

Diez

[Diez B. Roggisch]

Hi,

Also, why 'has children' is never printed?
The code is somewhat complicated, however the reason for "has children" not
beeing printed is simply that for the example no node matches the condition
- nodes A,B,C are the only ones with siblings, and none of them has a child
node....
I know there are easier ways to do this, but i want to do it using dom.

I'm not sure what easier ways _you_ think of - but to me it looks like a
classic field for XSLT, which is much more convenient to deal with. DOM is
usually PIA, don't mess around with it if you're not forced to.

Diez

[Andrew Clover]

sp***********@ntlworld.com (deglog) wrote:

def deepen(nodeList):
for node in nodeList:
[...]
node.previousSibling.appendChild(node)

Bzzt: destructive iteration gotcha.

DOM NodeLists are 'live': when you move a child Element out of the parent,
it no longer exists in the childNodes list. So in the example:

<a/>
<b/>
<c/>

the first element (a) cannot be moved and is skipped; the second element (b)
is moved into its previousSibling (a); the third element... wait, there is no
third element any more because (c) is now the second element. So the loop
stops.

A solution would be to make a static copy of the list beforehand. There's no
standard-DOM way of doing that and the Python copy() method is not guaranteed
to work here, so use a list comprehension or map:

identity= lambda x: x
for node in map(identity, nodeList):
...

--
Andrew Clover
mailto:an*@doxdesk.com
http://www.doxdesk.com/

[John J. Lee]

an********@doxdesk.com (Andrew Clover) writes:

sp***********@ntlworld.com (deglog) wrote: [...] A solution would be to make a static copy of the list beforehand. There's no
standard-DOM way of doing that and the Python copy() method is not guaranteed
to work here, so use a list comprehension or map:

identity= lambda x: x
for node in map(identity, nodeList):
...

Why not just

for node in list(nodeList):
...

?
John

[deglog]

Thanks for the help - this works and i understand how, and why.

jj*@pobox.com (John J. Lee) wrote in message news:<87************@pobox.com>...

Why not just

for node in list(nodeList):
...

?
John

the following also works (as i intended):

from xml.dom.NodeFilter import NodeFilter

def appendToDescendant(node):
walker.previousSibling()
while 1:
if walker.currentNode.hasChildNodes():
next = walker.nextNode()
else: break
walker.currentNode.appendChild(node)

walker = doc.createTreeWalker(doc.documentElement,NodeFilte r.SHOW_ELEMENT,
None, 0)
while 1:
print walker.currentNode.nodeName
if walker.currentNode.previousSibling != None:
print "ps "+walker.currentNode.previousSibling.nodeName
if walker.currentNode.previousSibling.nodeName != "Game":
if walker.currentNode.previousSibling.hasChildNodes() :
appendToDescendant(walker.currentNode)
else:
walker.currentNode.previousSibling.appendChild(wal ker.currentNode)
next = walker.nextNode()
if next is None: break

Strangely, the line checking "Game" is needed, because this firstnode
is its own previous sibling - how can this be right?

for example with the input file:
---
<?xml version="1.0" encoding="utf-8"?>
<Game/>
---
the ouptput is:
---
Game
ps Game
<?xml version='1.0' encoding='UTF-8'?>
<Game/>

[Andrew Clover]

John J. Lee <jj*@pobox.com> wrote:

Why not just for node in list(nodeList)?
You're right! I never trusted list() to make a copy if it was already a
native list (as it is sometimes in eg. minidom) but, bothering to check the
docs, it is guaranteed to after all. Hurrah.

sp***********@ntlworld.com (deglog) wrote:
def appendToDescendant(node):
walker.previousSibling()
while 1:
if walker.currentNode.hasChildNodes():
next = walker.nextNode()
else: break
walker.currentNode.appendChild(node)
Are you sure this is doing what you want? A TreeWalker's nextNode() method
goes to an node's next matching sibling, not into its children. To go into
the matching children you'd use TreeWalker.firstChild().

The function as written above appends the argument node to the first sibling
to have no child nodes, starting from the TreeWalker's current node or its
previous sibling if there is one.

I'm not wholly sure I understand the problem you're trying to solve. If you
just want to nest sibling elements as first children, you could do it without
Traversal or recursion, for example:

def nestChildrenIntoFirstElements(parent):
elements= [c for c in parent.childNodes if c.nodeType==c.ELEMENT_NODE]
if len(elements)>=2:
insertionPoint= elements[0]
for element in elements[1:]:
insertionPoint.appendChild(element)
insertionPoint= element

(Untested but no reason it shouldn't work.)
Strangely, the line checking "Game" is needed, because this firstnode
is its own previous sibling - how can this be right?

4DOM is fooling you. It has inserted a <!DOCTYPE> declaration automatically
for you. (It probably shouldn't do that.) So the previous sibling of the
documentElement is the doctype; of course the doctype has the same nodeName
as the documentElement, so the debugging output is misleading.

--
Andrew Clover
mailto:an*@doxdesk.com
http://www.doxdesk.com/

[deglog]

an********@doxdesk.com (Andrew Clover) wrote in message news:<2c**************************@posting.google. com>...

def appendToDescendant(node):
walker.previousSibling()
while 1:
if walker.currentNode.hasChildNodes():
next = walker.nextNode()
else: break
walker.currentNode.appendChild(node)
Are you sure this is doing what you want? A TreeWalker's nextNode() method
goes to an node's next matching sibling, not into its children. To go into
the matching children you'd use TreeWalker.firstChild().

right

I'm not wholly sure I understand the problem you're trying to solve.

actually i'm trying to change the relationship 'is next sibling of' to
'is child of' throughout a document

my latest idea is to go to the end of the document, then walk it
backwards (for christmas?:-) towards this end i wrote:
---
walker = doc.createTreeWalker(doc.documentElement,NodeFilte r.SHOW_ELEMENT,
None, 0)
while 1:
print '1 '+walker.currentNode.nodeName
next = walker.nextNode()
if next is None: break
print '2 '+walker.currentNode.nodeName
---
which, given
---
<?xml version="1.0" encoding="utf-8"?>
<Game><A/></Game>

---
outputs
---
1 Game
1 A
2 Game
---
foiled again. How come the current node is back at the start atfter
the loop has finished?

[Andrew Clover]

sp***********@ntlworld.com (deglog) wrote:

actually i'm trying to change the relationship 'is next sibling of' to
'is child of' throughout a document
Well, the snippet in the posting above should do that well enough. What
happens to any existing nested children is not defined.
How come the current node is back at the start atfter the loop has finished?

Bug. I've just submitted a patch to the PyXML tracker to address this issue.

(Note: earlier versions of TreeWalker - certainly 0.8.0 - have more significant
bugs, that can lead to infinite recursion.)

That said, I'm not sure how using a TreeWalker or walking backwards actually
helps you here! If you are just using it to filter out non-element children,
remember that moving the current node takes the position of the TreeWalker
with it. It's not like NodeIterator.

--
Andrew Clover
mailto:an*@doxdesk.com
http://www.doxdesk.com/

[deglog]

an********@doxdesk.com (Andrew Clover) wrote in message news:<2c**************************@posting.google. com>...

Bug. I've just submitted a patch to the PyXML tracker to address this issue.

(Note: earlier versions of TreeWalker - certainly 0.8.0 - have more significant
bugs, that can lead to infinite recursion.)

Thanks.

Does the function def __regress(self) from the same package need a similar fix?

(i am using PyXml 0.8.3)

[Andrew Clover]

sp***********@ntlworld.com (deglog) wrote:

Does the function def __regress(self) from the same package need a similar
fix?

Nope, looks OK to me. There's no 'in between' state where the current node
ends up pointing somewhere it shouldn't in this one, because of the different
order of the next/previous-sibling step and the move-through-ancestor/descendant
step.

I haven't checked all of the rest of the code, though, so I can't guarantee
there aren't any other problems with 4DOM's Traversal/Range implementation.

--
Andrew Clover
mailto:an*@doxdesk.com
http://www.doxdesk.com/