mfbox_xmlparse.py

toolbox for spm 5 for data, model free analysis

from xml import sax
from UserDict import DictMixin
import numpy
import string, re

def checkchar(x):
    return not ((not ((ord(x)>47 and ord(x)<58) or (ord(x)>96 and ord(x)<123) or (ord(x)>64 and ord(x)<91))) or ord(x)==59 or ord(x)==35)

def encode(s):
    return string.join(map(lambda x:x if checkchar(x) else "#%02d;"%(ord(x),),s),"")

def decode(s):
    p = re.compile("#[0-9]*;")
    for i in p.findall(s):
        c = chr(int(i[1:-1]))
        s = p.sub(c,s,1)
    return s

def ind2pos(i, s):
    l = 1
    v = []
    for j in range(0, len(s)):
        i /= l
        if j<len(s)-1:
            v.append(i%s[j])
        else:
            v.append(i)
        l *= s[j]
    return v
    
def pos2ind(p, s):
    l = 1
    v = 0
    for j in range(0, len(s)):
        v += p[j]*l
        l *= s[j]
    return v

def parsefloat(f):
    if f[-1]=="i":
        f = f[0:-1]
        a = f.split("+")
        if len(a)==2:
            return complex(float(a[0]),float(a[1]))
        elif len(a)==4:
            return complex(float(string.join(a[0:2],"+")),float(string.join(a[2:4],"+")))
        elif len(a)==3:
            try:
                return complex(float(string.join(a[0:2],"+")),float(string.join(a[2:3],"+")))
            except:
                return complex(float(string.join(a[0:1],"+")),float(string.join(a[1:3],"+")))
    else:
        return float(f)

class structmember(object,DictMixin):
    __de = {}
    __parent = None
    
    def __init__(self, parent):
        self.__parent = parent
        self.__de = {}

    def __getattr__(self, name):
        try:
            return self.__getitem__(name)
        except:
            raise AttributeError

    def __getitem__(self, name):
        try:
            return self.__de.__getitem__(name)
        except:
            if name in self.__parent.__attr__():
                return None
        raise IndexError

    def __setattr__(self, name, data):
        if len(name)>1 and name[0:1]=="_":
            return object.__setattr__(self,name,data)
        try:
            return self.__setitem__(name,data)
        except:
            raise AttributeError

    def __setitem__(self, name, data):
        if type(name)==str or type(name)==unicode:
            self.__de.__setitem__(str(name),data)
            return
        raise IndexError
    
    def localkeys(self):
        return [i for i in self.__de.__iter__()]

    def allkeys(self):
        p = []
        for i in self.__de.__iter__():
            p.append(i)
            yield i
        for i in self.__parent.__attr__():
            if i not in p:
                yield i

    def keys(self):
        return [x for x in self.allkeys()]

    def __repr__(self):
        return "<member of %s [%d] keys>"%(self.__parent.__repr__(),len(self.localkeys()))
    
    def __str__(self):
        ret = []
        for i,v in self.items():
           ret.append("%s -> %s"%(i,v.__str__())) 
        return string.join(ret, "\n")
    
class cell:
    __size = [0, 0]
    __elements = {}

    def __init__(self, *size):
        if len(size)>1:
            self.__size = size
        elif len(size)>0:
            self.__size = [size[0],size[0]]
        self.__elements = {}

    def __getattr__(self, name):
        if name=="size":
            return self.__size

    def __getitem__(self, pos):
        if type(pos)==list or type(pos)==tuple:
            return self.__call__(*pos)
        return self.__call__(pos)
    
    def __setitem__(self, pos, data):
        if type(pos)==list or type(pos)==tuple:
            return self.set(data,*pos)
        return self.set(data,pos)
    
    def __delitem__(self, pos):
        return self.set(None,*pos)
    
    def checksize(self, pos):
        ext = False
        size = [x for x in self.__size] 
        for  i in range(0, len(pos)):
            if i>=len(self.__size):
               self.__size.append(1)
            if pos[i]>=self.__size[i]:
                size[i] = pos[i]+1
                ext = True
        return (ext, size)
    
    def extend(self, size):
        elements = {}
        for i, e in self.__elements.items():
            j = pos2ind(ind2pos(i, self.__size), size)
            elements[j] = e
        self.__size = size
        self.__elements = elements

    def append(self, data):
        l = reduce(lambda x, y:x*y, self.__size)
        if len(self.__size)==2 and self.__size[1]<=1:
            pos = [l+1, 1]
        else:
            pos = ind2pos(l+1, self.__size)
        self.set(data, *pos)
    
    def __len__(self, data):
        return reduce(lambda x, y:x*y, self.__size)

    def __iter__(self):
        l = reduce(lambda x, y:x*y, self.__size)
        for  i in range(0,l):
            if self.__elements.has_key(i):
                yield self.__elements[i]
            else:
                yield None
    
    def __contains__(self, data):
        for i in self:
            if i==data:
                return True
        return False

    def set(self, data, *pos):
        if len(pos)>1:
            pos = pos2ind(pos, self.__size)
            if p[0]:
                self.extend(p[1])
            l = pos2ind(pos, self.__size)
        else:
            l = pos[0]
            if self.__size[0]==0 or self.__size[1]==1:
                self.__size = [l+1,1]
            else:
                pos = ind2pos(l,self.__size)
                p = self.checksize(pos)
                if p[0]:
                    self.extend(p[1])
                l = pos2ind(pos, self.__size)
        self.__elements[l] = data
    
    def reshape(self, *size):
        l = reduce(lambda x, y:x*y, size)
        m = reduce(lambda x, y:x*y, self.__size)
        if m==l:
            self.__size = size
        else:
            raise IndexError

    def __repr__(self):
        return "<cell of size [%s]>"%(string.join(map(str, self.__size), ","))

    def __str__(self):
        ret =["("]
        for i, v in self.__elements.items():
           ret.append("[%s] = %s"%(string.join(map(str, ind2pos(i, self.__size)), ","),v.__str__())) 
        ret.append(")")
        return string.join(ret, "\n")
    
    def __call__(self, *pos):
        ret = None
        if len(pos)>1:
            p = self.checksize(pos)
            if p[0]:
                self.extend(p[1])
            l = pos2ind(pos, self.__size)
        else:
            l = pos[0]
            if self.__size[0]==0 or self.__size[1]==1:
                self.__size = [l+1, 1]
            else:
                pos = ind2pos(l, self.__size)
                p = self.checksize(pos)
                if p[0]:
                    self.extend(p[1])
                l = pos2ind(pos, self.__size)
        if self.__elements.has_key(l):
            ret = self.__elements[l]
        else:
            self.__elements[l] = ret
        return ret

class struct:
    __size = [0, 0]
    __elements = {}
    
    def __init__(self, *size):
        if len(size)>1:
            self.__size = size
        elif len(size)>0:
            self.__size = [size[0],size[0]]
        l = reduce(lambda x, y:x*y, self.__size)
        self.__elements = {}
        for i in range(0,l):
            self.__elements[i] = structmember(self)

    def __size__(self):
        return self.__size

    def __attr__(self):
        return tuple(set(reduce(lambda x,y:x+y,[x.localkeys() for x in self.__elements.values()],[])))

    def __getattr__(self, name):
        l = reduce(lambda x, y:x*y, self.__size)
        if name in self.__attr__():
            if l>1:
                c = cell(*(self.__size))
                for i,v in self.__elements.items():
                    c[i] = v[name]
                return c
            else:
                return self.__elements[0][name]
        raise AttributeError

    def __getitem__(self, pos):
        if type(pos)==list or type(pos)==tuple:
            return self.__call__(*pos)
        return self.__call__(pos)
    
    def __setitem__(self, pos, data):
        if type(pos)==list or type(pos)==tuple:
            return self.set(data,*pos)
        return self.set(data,pos)
    
    def __delitem__(self, pos):
        return self.set(None,*pos)
    
    def set(self, data, *pos):
        if type(data)==dict:
            if len(pos)>1:
                p = pos2ind(pos, self.__size)
                if p[0]:
                    self.extend(p[1])
                l = pos2ind(pos, self.__size)
            else:
                l = pos[0]
                if self.__size[0]==0 or self.__size[1]==1:
                    self.__size = [l+1, 1]
                else:
                    pos = ind2pos(l, self.__size)
                    p = self.checksize(pos)
                    if p[0]:
                        self.extend(p[1])
                    l = pos2ind(pos, self.__size)
            e = structmember(self)
            for i,v in data.items():
                e[i] = v
            self.__elements[l] = e
        else:
            raise AttributeError
    
    def reshape(self, *size):
        l = reduce(lambda x, y:x*y, size)
        m = reduce(lambda x, y:x*y, self.__size)
        if m==l:
            self.__size = size
        else:
            raise IndexError

    def checksize(self, pos):
        ext = False
        size = [x for x in self.__size] 
        for  i in range(0, len(pos)):
            if i>=len(self.__size):
               self.__size.append(1)
            if pos[i]>=self.__size[i]:
                size[i] = pos[i]+1
                ext = True
        return (ext, size)
    
    def extend(self, size):
        elements = {}
        for i, e in self.__elements.items():
            j = pos2ind(ind2pos(i, self.__size), size)
            elements[j] = e
        self.__size = size
        self.__elements = elements
        l = reduce(lambda x, y:x*y, self.__size)
        for i in range(0,l):
            if not self.__elements.has_key(i):
                self.__elements[i] = structmember(self)

    def append(self, data):
        l = reduce(lambda x, y:x*y, self.__size)
        if len(self.__size)==2 and self.__size[1]<=1:
            pos = [l+1, 1]
        else:
            pos = ind2pos(l+1, self.__size)
        self.set(data, *pos)
    
    def __len__(self, data):
        return reduce(lambda x, y:x*y, self.__size)
    
    def __iter__(self):
        l = reduce(lambda x, y:x*y, self.__size)
        for  i in range(0,l):
            if not self.__elements.has_key(i):
                self.__elements[i] = structmember(self)
            yield self.__elements[i]
    
    def __repr__(self):
        return "<struct of size [%s]>"%(string.join(map(str, self.__size), ","))

    def __str__(self):
        ret =["["]
        for i, v in self.__elements.items():
           ret.append("[%s] = %s"%(string.join(map(str, ind2pos(i, self.__size)), ","),v.__str__().replace("\n",", "))) 
        ret.append("]")
        return string.join(ret, "\n")
    
    def __call__(self, *pos):
        ret = None
        if len(pos)>1:
            p = self.checksize(pos)
            if p[0]:
                self.extend(p[1])
            l = pos2ind(pos, self.__size)
        else:
            l = pos[0]
            if self.__size[0]==0 or self.__size[1]==1:
                self.__size = [l+1, 1]
            else:
                pos = ind2pos(l, self.__size)
                p = self.checksize(pos)
                if p[0]:
                    self.extend(p[1])
                l = pos2ind(pos, self.__size)
        if self.__elements.has_key(l):
            ret = self.__elements[l]
        else:
            ret = structmember(self)
            self.__elements[l] = ret
        return ret

MATRIX = {}
CELL = {}
STRUCT = {}

class nameddata:
    __name = None
    __data = None
    
    def __init__(self, name, data):
        self.__name = name
        self.__data = data

    def name(self):
        return self.__name

    def data(self):
        return self.__data

class MfboxXmlUnmarshal:
    unmarshal_meth = {
        'mfbox': ('um_start_root', None),
        'int32': ('um_start_int', 'um_end_int'),
        'double': ('um_start_float', 'um_end_float'),
        'logical': ('um_start_bool', 'um_end_bool'),
        'char': ('um_start_string', 'um_end_string'),
        'cell': ('um_start_cell', 'um_end_cell'),
        'struct': ('um_start_struct', 'um_end_struct'),