Extract name in xsd

extract_names_xml.py

import xml.etree.ElementTree as ET
from copy import deepcopy

class Entry:
        def __init__(self,name,path=None,val=None):
          self.name=name
          self.path=path
          self.val=val

        def __str__(self):
            return '{}:{}:{}'.format(self.name,self.val,self.path)


class XMLParser:
    
    def __init__(self, xml_data):
        self.root = ET.parse(xml_data).getroot()
        self.nodes= {} #to solve references
        self.pairs= [] # where to updates the tree to include references
        self.names =[] # pairs of names in xsd

    def parse_root(self, root):
        return [self.parse_element(child) for child in iter(root)]

    def reparse_root(self, root):
        return [self.reparse_element(child) for child in iter(root)]

    def parse_element(self, element):        
        name = element.attrib.get("name")
        if name is not None:
          self.nodes[name]=element

    def findref(self,element):
      t=False
      ref = element.attrib.get("ref")
      #print ref
      if ref is None:
        return
      if ref in self.nodes:
        t=True
      else:
        if ':' in ref:
          ref=ref[ref.index(":")+1:]
          if ref in self.nodes:
            t=True
        
      if t:
           self.pairs.append((element,self.nodes[ref]))     

    def reparse_element(self, element):
        self.findref(element)        
        for child in list(element):                        
            self.reparse_element(child)
        
        
    def process_data(self):
        self.parse_root(self.root)
        self.reparse_root(self.root)
  
    def indent(self, elem, level=1):
      i = "\n" + level*"  "
      j = "\n" + (level-1)*"  "
      if len(elem):
          if not elem.text or not elem.text.strip():
              elem.text = i + "  "
          if not elem.tail or not elem.tail.strip():
              elem.tail = i
          for subelem in elem:
              self.indent(subelem, level+1)
          if not elem.tail or not elem.tail.strip():
              elem.tail = j
      else:
          if level and (not elem.tail or not elem.tail.strip()):
              elem.tail = j
      return elem    
      
    def append(self):
        for p,r in self.pairs:
          p.append(deepcopy(r))
     
    
    def findnames(self,element,name=None,path=None):
       if name is None:
         name=element.attrib.get("name")
       else:
          val=element.attrib.get("name")

       if path is None:
          path=""
       if element.text is not None:
           path=path+element.text.replace("\n","")
        

       if element.attrib.get("name") is not None:
            path=path+element.attrib.get("name")
       
       nchild = 0 
       for child in list(element):            
            nchild +=1
            self.findnames(child, name, path)
        
       if nchild ==0:
            if name is not None:
             if val is not None:   
               self.names.append(Entry(name,path,val))

    def find_name_pairs(self):
      self.findnames(self.root)
      return self.names 

xmldata="cnf.xsd"
xmlp = XMLParser(xmldata)
xmlp.process_data()
xmlp.append()
#root = xmlp.root
#xmlp.indent(root,1)
#ET.dump(root)

xmlp.find_name_pairs()
for i in xmlp.names:
    print(i)