diff --git a/pisi/xmlfile.py b/pisi/xmlfile.py
index 05b3facd..5a5c2bb6 100644
--- a/pisi/xmlfile.py
+++ b/pisi/xmlfile.py
@@ -16,13 +16,6 @@
 
 
 """
- xmlfile is a helper module for accessing XML files using
- xml.dom.minidom.
-
- XmlFile class further abstracts a dom object using the
- high-level dom functions provided in xmlext module (and sorely lacking
- in xml.dom :( )
-
  autoxml is a metaclass for automatic XML translation, using
  a miniature type system. (w00t!) This is based on an excellent
  high-level XML processing prototype that Gurer prepared.
@@ -791,123 +784,3 @@ class autoxml(oo.autosuper, oo.autoprop):
         types.FloatType : float,
         types.LongType : long
         }
-
-
-class XmlFile(object):
-    """A class to help reading and writing an XML file"""
-
-    def __init__(self, tag):
-        self.rootTag = tag
-        self.newDOM()
-
-    def newDOM(self):
-        """clear DOM"""
-        impl = mdom.getDOMImplementation()
-        self.dom = impl.createDocument(None, self.rootTag, None)
-
-    def unlink(self):
-        """deallocate DOM structure"""
-        self.dom.unlink()
-
-    def rootNode(self):
-        """returns root document element"""
-        return self.dom.documentElement
-
-    def readxml(self, fileName):
-        try:
-            self.dom = mdom.parse(fileName)
-        except ExpatError, inst:
-            raise Error(_("File '%s' has invalid XML: %s\n") % (fileName,
-                                                                str(inst)))
-
-    def writexml(self, fileName):
-        f = codecs.open(fileName,'w', "utf-8")
-        f.write(self.dom.toprettyxml())
-        f.close()
-
-    def verifyRootTag(self):
-        actual_roottag = self.rootNode().tagName
-        if actual_roottag != self.rootTag:
-            raise Error(_("Root tagname %s not identical to %s as expected") %
-                        (actual_roottag, self.rootTag) )
-
-    # construction helpers
-
-    def newNode(self, tag):
-        return self.dom.createElement(tag)
-
-    def newTextNode(self, text):
-        return self.dom.createTextNode(text)
-
-    def newAttribute(self, attr):
-        return self.dom.createAttribute(attr)
-
-    # read helpers
-
-    def getNode(self, tagPath = ""):
-        """returns the *first* matching node for given tag path."""
-        self.verifyRootTag()
-        return getNode(self.dom.documentElement, tagPath)
-
-    def getNodeText(self, tagPath):
-        """returns the text of *first* matching node for given tag path."""
-        node = self.getNode(tagPath)
-        if not node:
-            return None
-        return getNodeText(node)
-
-    def getAllNodes(self, tagPath):
-        """returns all nodes matching a given tag path."""
-        self.verifyRootTag()
-        return getAllNodes(self.dom.documentElement, tagPath)
-
-    def getChildren(self, tagpath):
-        """ returns the children of the given path"""
-        node = self.getNode(tagpath)
-        return node.childNodes
-
-    # get only elements of a given type
-    #FIXME:  this doesn't work
-    def getChildrenWithType(self, tagpath, type):
-        """ returns the children of the given path, only with given type """
-        node = self.getNode(tagpath)
-        return filter(lambda x:x.nodeType == type, node.childNodes)
-
-    # get only child elements
-    def getChildElts(self, tagpath):
-        """ returns the children of the given path, only with given type """
-        node = self.getNode(tagpath)
-        try:
-            return filter(lambda x:x.nodeType == x.ELEMENT_NODE,
-                          node.childNodes)
-        except AttributeError:
-            return None
-
-    # write helpers
-
-    def addNode(self, tagPath, newnode = None):
-        "this adds the newnode under given tag path"
-        self.verifyRootTag()
-        return addNode(self.dom.documentElement, tagPath, newnode)
-
-    def addNodeUnder(self, node, tagPath, newnode = None):
-        "this adds the new stuff under node and then following tag path"
-        self.verifyRootTag()
-        return addNode(node, tagPath, newnode)
-
-    def addChild(self, newnode):
-        "add a new child node right under root element document"
-        self.dom.documentElement.appendChild(newnode)
-
-    def addText(self, node, text):
-        "add text to node"
-        node.appendChild(self.newTextNode(text))
-
-    def addTextNode(self, tagPath, text):
-        "add a text node with given tag path"
-        node = self.addNode(tagPath, self.newTextNode(text))
-        return node
-
-    def addTextNodeUnder(self, node, tagPath, text):
-        "add a text node under given node with tag path (phew)"
-        return self.addNodeUnder(node, tagPath, self.newTextNode(text))