First import; synced with SVN

.gitignore

+# exclude pyc files
+*.pyc

src/xmlconfig.py

+# -*- coding: utf-8 -*-
+dbg_ = False    
+import sys
+from xml.dom import minidom
+from UserDict import UserDict
+#rom collections import namedtuple
+import traceback
+
+class InvalidFileError(Exception): 
+       def __init__(self, value):
+           self.message = value
+       def __str__(self):
+           return repr(self.message)
+
+
+import urllib                         
+import StringIO
+
+def open_anything(source):            
+    """URI, filename, or string --> stream
+
+    This function lets you define parsers that take any input source
+    (URL, pathname to local or network file, or actual data as a string)
+    and deal with it in a uniform manner.  Returned object is guaranteed
+    to have all the basic stdio read methods (read, readline, readlines).
+    Just .close() the object when you're done with it.
+    
+    Examples::
+        
+        >>> from xml.dom import minidom
+        >>> sock = open_anything("http://localhost/kant.xml")
+        >>> doc = minidom.parse(sock)
+        >>> sock.close()
+        >>> sock = open_anything("c:\\inetpub\\wwwroot\\kant.xml")
+        >>> doc = minidom.parse(sock)
+        >>> sock.close()
+        >>> sock = open_anything("<ref id='conjunction'><text>and</text><text>or</text></ref>")
+        >>> doc = minidom.parse(sock)
+        >>> sock.close()
+    """
+    if hasattr(source, "read"):
+        return source
+
+    if source == '-':
+        return sys.stdin
+
+    # try to open with urllib (if source is http, ftp, or file URL)
+
+    try:                                  
+        return urllib.urlopen(source)     
+    except (IOError, OSError):            
+        pass                             
+    
+    # try to open with native open function (if source is pathname)
+    try:                                  
+        return open(source)               
+    except (IOError, OSError):            
+        pass
+    
+    # treat source as string
+                           
+    return StringIO.StringIO(str(source))
+
+def _get_text(nodelist):
+    """ Extract an string from a xml node data."""        
+    rc_ = [node.data for node in nodelist 
+                if node.nodeType == node.TEXT_NODE]                
+    return ''.join(rc_).strip().encode('ascii')
+
+def _get_value(node, tagname):
+    """ Extract the value from an xml node"""
+    values = node.getElementsByTagName(tagname)
+    if len(values) == 0:
+        return ''
+    internal_node = values[0]
+    return _get_text(internal_node.childNodes)
+        
+
+READ_ONLY = 0
+READ_WRITE = 1
+WRITE_ONLY = 2     
+IS_COMMAND = 3
+
+class XmlItem:
+
+    def __init__(self, flag , type, handler, name, tango_name, 
+                 description="", default=None, dimension = 1, 
+                 memorized = 0 , read_function = '' , write_function = ''):
+        self.flag = flag
+        self.type = type
+        self.handler = handler
+        self.tango_name = tango_name
+        self.name = name
+        self.description = description
+        self.default = default
+        self.dimension = dimension
+        self.memorized = memorized
+        self.read_function = read_function
+        self.write_function = write_function
+    
+    def __str__(self):
+        return "Attr %s = %s/%s \n %s \n %s %d \n %s \n %s"% (self.name, self.handler, 
+                                    self.name, self.description, self.default, 
+                                    self.memorized, self.read_function, self.write_function)
+
+class ScriptXmlConfig:
+    """
+    Parser of the XML file in python usefull class
+    
+    attributes a dict with: 
+        - flag: read_only, write_only, read_write
+        - type: short, double, string, 
+        - handler: tango attribute associated
+        - name: name or label of this attribute
+        - description: information for the attribute
+       	- memorized: uses Tango Memorize feature, available only for scalar attributes
+        - default: default value ( WARNING: is loaded using eval() )
+       	- read_function: name of the function that will be executed for every read operation
+       	- write_function: name of the function that will be executed for every write operation
+                
+    """
+    def __init__(self, filename):
+        self.entries = dict()
+        self.doc = self._load(filename)
+        self._parse()
+    
+    def __str__(self):
+        return "DaqXmlConfig %s %s"% (str(self.attributes))
+        
+    def _parse(self):
+        """Parse the xml file"""
+        try:
+            self.handle_entries(self.doc.getElementsByTagName("ATTRIBUTES_RO"),flag=READ_ONLY)
+            self.handle_entries(self.doc.getElementsByTagName("ATTRIBUTES_RW"),flag=READ_WRITE)
+            self.handle_entries(self.doc.getElementsByTagName("ATTRIBUTES_WO"),flag=WRITE_ONLY)
+            self.handle_entries(self.doc.getElementsByTagName("COMMANDS"),flag=IS_COMMAND)
+        except IndexError:
+            traceback.print_exc()
+            raise InvalidFileError(
+                    "Failed to parse the configuration file")        
+    @classmethod   
+    def _load(cls, source):
+        """load XML input source, return parsed XML document
+        
+        - a URL of a remote XML file ("http://diveintopython.org/kant.xml")
+        - a filename of a local XML file ("~/diveintopython/common/py/kant.xml")
+        - standard input ("-")
+        - the actual XML document, as a string
+        """
+        sock = open_anything(source)
+        try:        
+            xmldoc = minidom.parse(sock).documentElement
+        except Exception, ex:
+            raise InvalidFileError(str(ex))
+        sock.close()
+        return xmldoc
+    
+    def handle_entries(self, elements, flag):
+        
+        for group_of_attributes in elements:
+            attributes = [attribute 
+                            for attribute 
+                            in group_of_attributes.childNodes if 
+                            attribute.nodeType == 1]
+            for attribute in attributes:
+                type = _get_value(attribute, 'TYPE')
+                handler = _get_value(attribute,'HANDLER')
+                attr = handler +'/' + _get_value(attribute, 'TANGONAME')
+                name = attribute.nodeName
+                desc =_get_value(attribute, 'DESCRIPTION')
+                dimension_s = _get_value(attribute, 'DIMENSION')
+                if dimension_s == '':
+                    dimension = 1
+                elif dimension_s.find('(')>= 0:
+                    dimension = eval(dimension_s)
+                else:
+                    dimension = int(dimension_s)                
+                memorized_s = _get_value(attribute, 'MEMORIZED')
+                if memorized_s == '1' and dimension == 1 :
+                    memorized = 1
+                else :
+                    memorized = 0
+                #
+                default_v = _get_value(attribute, 'DEFAULT')
+                #
+                read_function = _get_value(attribute, 'READ_FUNCTION')
+                write_function = _get_value(attribute, 'WRITE_FUNCTION')
+                #
+                attr_entry = XmlItem(flag, type,handler,name,attr,desc,default_v,dimension,memorized,read_function,write_function)
+                if dbg_: print attr_entry
+                self.entries[attr_entry.name] = attr_entry
+
+                
+                
+
+if __name__ == "__main__":
+    xml = ScriptXmlConfig("./scripts/ldm_daq_conf.xml")