changed the templates to follow the pep spec

pyogp/lib/base/message_template.py

@@ -23,10 +23,13 @@ limitations under the License.
 $/LicenseInfo$
 """
 
-from makepacketdict import makepacketdict, makereversepacketdict
+#standard libraries
 import struct
 import pprint
 
+#local libraries
+from makepacketdict import makepacketdict, makereversepacketdict
+
 mypacketdictionary = makepacketdict()
 myreversedictionary = makereversepacketdict()
 
@@ -49,10 +52,10 @@ class MessageTemplateVariable():
         self.name = name
         self.lltype = tp
 
-    def getName(self):
+    def get_name(self):
         return self.name
 
-    def getType(self):
+    def get_type(self):
         return self.lltype
 
 class MessageTemplateBlock():
@@ -66,22 +69,22 @@ class MessageTemplateBlock():
         else:
             self.number = 0
 
-    def getBlockType(self):
+    def get_block_type(self):
         return self.blockType
 
-    def getBlockNumber(self):
+    def get_block_number(self):
         return self.number
 
-    def getName(self):
+    def get_name(self):
         return self.name
 
-    def addVar(self, var):
-        self.vars[var.getName()] = var
+    def add_var(self, var):
+        self.vars[var.get_name()] = var
 
-    def getVariables(self):
+    def get_variables(self):
         return self.vars.values()
 
-    def getVariable(self, name):
+    def get_variable(self, name):
         return self.vars[name]
 
 class MessageTemplate():
@@ -98,33 +101,35 @@ class MessageTemplate():
         else:
             self.msgDeprecation = ''
             
-    def getFrequency(self):
+    def get_frequency(self):
         return self.frequency
 
-    def getMessageNumber(self):
+    def get_message_number(self):
         return self.msgNum
 
-    def getMessageTrust(self):
+    def get_message_trust(self):
         return self.msgTrust
 
-    def getMessageEncoding(self):
+    def get_message_encoding(self):
         return self.msgEncoding
 
-    def getDeprecation(self):
+    def get_deprecation(self):
         return self.msgDeprecation
 
-    def getName(self):
+    def get_name(self):
         return self.name
 
-    def addBlock(self, block):
-        self.blocks[block.getName()] = block
+    def add_block(self, block):
+        self.blocks[block.get_name()] = block
 
-    def getBlocks(self):
+    def get_blocks(self):
         return self.blocks.values()
         
-    def getBlock(self, name):
+    def get_block(self, name):
         return self.blocks[name]
-    
+
+
+#these remain unformatted (by standard) because they are going to be moved    
 def decodeHeaderPair(frequency, num):
     return mypacketdictionary[(frequency, num)]
 

pyogp/lib/base/message_template_parser.py

@@ -1,20 +1,23 @@
+#standard libraries
 import re
-import message_template
 import pprint
+
+#local libraries
+import message_template
 from pyogp.lib.base.data import msg_tmpl
 
-class Message_Template_Parser():
+class MessageTemplateParser():
     def __init__(self):
         self.message_templates = {}
-
-    def getTemplateList(self):
+    
+    def get_template_list(self):
         return self.message_templates.values()
 
-    def getTemplate(self, name):
+    def get_template(self, name):
         return self.message_templates[name]
 
-    def addTemplate(self, new_template):
-        self.message_templates[new_template.getName()] = new_template
+    def add_template(self, new_template):
+        self.message_templates[new_template.get_name()] = new_template
 
     def parse_template_file(self, template_file):
         count = 0
@@ -45,7 +48,7 @@ class Message_Template_Parser():
                 parts = parts.split()
                 
                 current_packet = message_template.MessageTemplate(parts)
-                self.addTemplate(current_packet)
+                self.add_template(current_packet)
 
             block_header = re.match("^\t\t([^{}]+.+)",line) #gets packet block header
             if block_header != None:
@@ -53,7 +56,7 @@ class Message_Template_Parser():
                 parts = parts.split()
                 
                 current_block = message_template.MessageTemplateBlock(parts)
-                current_packet.addBlock(current_block)
+                current_packet.add_block(current_block)
                 
             block_data  = re.match("^\t\t([{}]+.+)",line)  #gets block data
             if block_data != None:
@@ -62,42 +65,42 @@ class Message_Template_Parser():
                 parts.remove('{')
                 parts.remove('}')
                 current_var = message_template.MessageTemplateVariable(parts[0], parts[1])
-                current_block.addVar(current_var)
+                current_block.add_var(current_var)
 
 def print_packet_list(packet_list):
     for packet in packet_list:
         print '======================================'
-        print packet.getName() + ' ' + packet.getFrequency() + ' ' + \
-                packet.getMessageNumber() + ' ' + packet.getMessageTrust() + ' ' + \
-                packet.getMessageEncoding() + '' + packet.getDeprecation()
+        print packet.get_name() + ' ' + packet.get_frequency() + ' ' + \
+                packet.get_message_number() + ' ' + packet.get_message_trust() + ' ' + \
+                packet.get_message_encoding() + '' + packet.get_deprecation()
         
-        for block in packet.getBlocks():
-            print '\t' + block.getName() + ' ' + block.getBlockType() + ' ' + \
-                  str(block.getBlockNumber())
-            for variable in block.getVariables():
-                sz = len(variable.getName())
-                print '\t\t' + variable.getName() + variable.getType().rjust(30 - sz)
+        for block in packet.get_blocks():
+            print '\t' + block.get_name() + ' ' + block.get_block_type() + ' ' + \
+                  str(block.get_block_number())
+            for variable in block.get_variables():
+                sz = len(variable.get_name())
+                print '\t\t' + variable.get_name() + variable.get_type().rjust(30 - sz)
 
 def get_all_types(packet_list):
     type_set = set([])
     for packet in packet_list:
-        for block in packet.getBlocks():
-            for variable in block.getVariables():
-                type_set.add(variable.getType())
+        for block in packet.get_blocks():
+            for variable in block.get_variables():
+                type_set.add(variable.get_type())
 
     type_list = list(type_set)
     type_list.sort()
     return type_list
 
 def main():
-    parser = Message_Template_Parser()
+    parser = MessageTemplateParser()
     parser.parse_template_file(msg_tmpl)
-    templates = parser.getTemplateList()
+    templates = parser.get_template_list()
     
     print_packet_list(templates)
 
     p_typelist = get_all_types(templates)
-    #pprint.pprint(p_typelist)
+    pprint.pprint(p_typelist)
     return
     
 if __name__ == "__main__":