Struct in Python and Heritance

Python is an extendable programming language , as you know it supports Object-Oriented programming though it is not a strong type language. How do you write a class to support heritance if you want to use it as 'struct' type in C Programming ? I think this is an interesting question. I will demo an example that how I achieve it.

First, you need to study 'struct — Interpret strings as packed binary data' in Python manuals. It will tell you how to pack and unpack binary data.

Second, you have to study '3.4.1 Basic customization' to know behavior of function '__new__'.

---

 import string;
 import struct;
 
 class StructMeta(type):
     __TYPE__ = ['x','c','b','B','?','h','H','i','I',
                 'l','L','q','Q','f','d','s','p','P'];
     ___struct___ = '___struct___';
     ___fields___ = '___fields___';
     ___fmt___ = '___fmt___';
 
     def __new__(cls, clsname, clsbases, clsdict):
         """
         This function will be recursive invoked when classes be loaded. 
         """
         clsdict2 = dict();
         fields = [];
         format = [];
         if(len(clsbases)>0):
             # It will come here if only if cls has parent class!
             parentFields = clsbases[0].__getattribute__(clsbases[0], StructMeta.___fields___);
             for field in parentFields :
                 fields.append(field);
                 
             parentFormat = clsbases[0].__getattribute__(clsbases[0], StructMeta.___fmt___);
             format.append(parentFormat);
 
         for field in clsdict:
             structDef = clsdict[field];
             if(string.find(field, StructMeta.___struct___)  < 0): 
                 clsdict2[field] = structDef;              
                 continue;
             for fieldDef in structDef:
                 name = fieldDef[0];
                 fmt = fieldDef[1];
                 if(fmt not in StructMeta.__TYPE__):
                     raise Exception("Not support type '"+fmt+"' at " + name);                     
                 format.append(fmt);
                 defaultVal = fieldDef[2];
                 if(name in fields):
                     raise Exception("Redefinition '"+name+"' at "+ field); 
                 fields.append(name);
                 clsdict2[name] = defaultVal;
  
         clsdict2[StructMeta.___fmt___] =  string.join(format,'');
         clsdict2[StructMeta.___fields___] = fields;
         return type.__new__(cls, clsname, clsbases, clsdict2);
         
 
 class StructObject:
     __metaclass__ = StructMeta;
     ___endian___ = '!';
     #@ native native 
     #= native standard 
     #< little-endian standard 
     #> big-endian standard 
     #! network (= big-endian) standard 
     """
     It support define struct type 
     """
     def __init__(self):
         pass;
     
     def setEndian(self, edian):
         self.___endian___ = edian;
     
     def unpack(self, buf):        
         values = struct.unpack(self.___endian___+ self.___fmt___,  buf);
         i = 0;
         for field in self.___fields___:
             self.__setattr__(field, values[i]); 
             i += 1;        
 
 class A(StructObject):    
     ___struct___A = (
         ('field1', 'H', 0),
     );        
 
 class B(A):
     ___struct___B = (
         ('field2', 'I', 0),
     );
 
 class C(B):
     ___struct___C = (
         ('field3', 'H', 0),
     );
     
 if __name__ == "__main__":
     
     obj = C();
     buf = '\x00\x02\x00\x00\x00\x04\x00\x06';
     obj.unpack(buf);
     print(obj.field1);
     print(obj.field2);
     print(obj.field3);
 
 ############### Output ###################
 # 2                                      #
 # 4                                      #
 # 6                                      #
 ##########################################

---

As you see in output, class A, class B and class C have different fields then 'obj' is an instance of class C. Then we unpack binary data and we could access fields that defined in different class.The class C has fields which inherits from class B and class A.

What is that we need to be careful of this design ?
1. You need to maintain definition of fields by yourself.
2. Don't redefine same filed name. It doesn't support field hiden.
3. The '___struct___' will not be an actual field in an instance of class C.