Changeset 680


Ignore:
Timestamp:
16/03/06 17:25:14 (14 years ago)
Author:
domlowe
Message:

UnitDefinition?(s), Dictionary, TimeCoordinateSystem? added

Location:
TI02-CSML/trunk/newparser
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • TI02-CSML/trunk/newparser/Parser.py

    r678 r680  
    129129    def fromXML(self,csmlFrag): 
    130130        self.data = csmlFrag.text 
    131 #Andrew: 
    132 ## For some reason, namespace on 'codeSpace' attribute not being picked up... 
    133 ##        if csmlFrag.attrib.has_key(GML('codeSpace')): 
    134 ##            self.codeSpace = csmlFrag.attrib[GML('codeSpace')] 
    135 #Dominic: 
    136 ##  I think this is because it has no explicit namespace in the XML doc eg.: <gml:name codeSpace="http://ndg.nerc.... 
    137 ## unlike say: gml:id which has the gml: prefix explicitly e.g. <gml:UnitDefinition gml:id="psu"> 
     131 
     132# For some reason, namespace on 'codeSpace' attribute not being picked up... 
     133#        if csmlFrag.attrib.has_key(GML('codeSpace')): 
     134#            self.codeSpace = csmlFrag.attrib[GML('codeSpace')] 
     135 
    138136 
    139137        if csmlFrag.attrib.has_key('codeSpace'): 
     
    198196        return csmlFrag 
    199197 
    200 class UnitDefinitions: 
     198             
     199class Definition(AbstractGML): 
     200    #Class definition, restricts AbstractGML 
     201    #gml:id is mandatory. 
     202    def __init__(self,*args,**kwargs): 
     203        AbstractGML.__init__(self,*args,**kwargs) 
     204    def fromXML(self,csmlFrag): 
     205        AbstractGML.fromXML(self,csmlFrag) 
     206        #TO DO: how  best to handle this? 
     207        if not hasattr(self,'id'): 
     208            print 'gml:id mandatory value missing in ' + csmlFrag.tag 
     209            sys.exit() 
     210    def toXML(self,csmlFrag): 
     211        csmlFrag=AbstractGML.toXML(self,csmlFrag) 
     212        return csmlFrag 
     213     
     214     
     215class TimeCoordinateSystem(Definition): 
     216    #Class for csml:TimeCoordinateSystem(gml:Definition) element 
     217    # + originPosition 
     218    # + interval 
     219    def __init__(self,originPosition=None,interval=None,unit=None,*args,**kwargs): 
     220        Definition.__init__(self,*args,**kwargs) 
     221        if originPosition: 
     222            self.originPosition=originPosition 
     223        if interval: 
     224            self.interval=interval 
     225        if unit: 
     226            self.unit=unit 
     227    def fromXML(self,csmlFrag): 
     228        Definition.fromXML(self,csmlFrag) 
     229        for frag in csmlFrag.getchildren(): 
     230            if frag.tag == GML('originPosition'): 
     231                self.originPosition=frag.text 
     232            elif frag.tag == GML('interval'): 
     233                self.interval=frag.text 
     234                self.unit = frag.attrib 
     235    def toXML(self,csmlFrag): 
     236        Definition.toXML(self,csmlFrag) 
     237        if hasattr(self, 'originPosition'): 
     238            frag=Element(GML('originPosition')) 
     239            frag.text=self.originPosition 
     240            csmlFrag.append(frag) 
     241        if hasattr(self, 'interval'): 
     242            frag=Element(GML('interval')) 
     243            frag.text=self.interval 
     244            if hasattr(self,'unit'): 
     245                frag.attrib=self.unit 
     246            csmlFrag.append(frag) 
     247        return csmlFrag 
     248 
     249class EngineeringCRS: 
    201250    def __init__(self): 
    202251        pass 
     
    206255        return csmlFrag 
    207256 
    208 class ReferenceSystemDefinitions: 
    209     def __init__(self): 
    210         pass 
    211     def fromXML(self,csmlFrag): 
    212         pass 
    213     def toXML(self,csmlFrag): 
    214         return csmlFrag 
    215  
    216 class PhenomenonDefinitions: 
    217     def __init__(self): 
    218         pass 
    219     def fromXML(self,csmlFrag): 
    220         pass 
    221     def toXML(self,csmlFrag): 
     257class UnitDefinition(Definition): 
     258        #Class gml:UnitDefinition 
     259        # +quantityType 
     260        # +catalogSymbol, codeSpace 
     261    def __init__(self,quantityType=None,catalogSymbol=None,codeSpace=None,*args,**kwargs): 
     262        Definition.__init__(self,*args,**kwargs) 
     263        if quantityType: 
     264            self.quantityType=quantityType 
     265        if catalogSymbol: 
     266            self.catalogSymbol=catalogSymbol 
     267    def fromXML(self,csmlFrag): 
     268        Definition.fromXML(self,csmlFrag) 
     269        for frag in csmlFrag.getchildren(): 
     270            if frag.tag == GML('quantityType'): 
     271                self.quantityType=frag.text 
     272            elif frag.tag == GML('catalogSymbol'): 
     273                self.catalogSymbol=frag.text 
     274                self.codeSpace = frag.attrib 
     275    def toXML(self,csmlFrag): 
     276        Definition.toXML(self,csmlFrag) 
     277        if hasattr(self, 'quantityType'): 
     278            frag=Element(GML('quantityType')) 
     279            frag.text=self.quantityType 
     280            csmlFrag.append(frag) 
     281        if hasattr(self, 'catalogSymbol'): 
     282            frag=Element(GML('catalogSymbol')) 
     283            frag.text=self.catalogSymbol 
     284            if hasattr(self,'codeSpace'): 
     285                frag.attrib=self.codeSpace 
     286            csmlFrag.append(frag) 
     287        return csmlFrag 
     288     
     289class Dictionary(Definition): 
     290    #Class for gml:Dictionary elements 
     291    # + gml:definitionMembers [1....*] 
     292    def __init__(self,definitionMembers=None,*args,**kwargs): 
     293        Definition.__init__(self,*args,**kwargs) 
     294        if definitionMembers: 
     295            self.definitionMembers = definitionMembers 
     296    def fromXML(self,csmlFrag): 
     297        Definition.fromXML(self,csmlFrag) 
     298        for frag in csmlFrag.getchildren(): 
     299            if frag.tag == GML('definitionMember'): 
     300                checkArrayAttrib(self, 'definitionMembers') 
     301                subFrag = frag.getchildren()[0] 
     302                if subFrag.tag == GML('UnitDefinition'): 
     303                    definitionMember=UnitDefinition() 
     304                    definitionMember.fromXML(subFrag) 
     305                    self.definitionMembers.append(definitionMember) 
     306                elif subFrag.tag == CSML('TimeCoordinateSystem'): 
     307                    definitionMember=TimeCoordinateSystem() 
     308                    definitionMember.fromXML(subFrag) 
     309                    self.definitionMembers.append(definitionMember) 
     310                elif subFrag.tag == GML('EngineeringCRS'): 
     311                    definitionMember=EngineeringCRS() 
     312                    definitionMember.fromXML(subFrag) 
     313                    self.definitionMembers.append(definitionMember) 
     314    def toXML(self,csmlFrag): 
     315        Definition.toXML(self,csmlFrag) 
     316        if hasattr(self, 'definitionMembers'): 
     317            for definitionMember in self.definitionMembers: 
     318                if isinstance(definitionMember,UnitDefinition): 
     319                    superFrag=Element(GML('definitionMember')) 
     320                    frag=Element(GML('UnitDefinition')) 
     321                    UnitDefinition.toXML(definitionMember,frag) 
     322                    superFrag.append(frag) 
     323                    csmlFrag.append(superFrag) 
     324                if isinstance(definitionMember,TimeCoordinateSystem): 
     325                    superFrag=Element(GML('definitionMember')) 
     326                    frag=Element(CSML('TimeCoordinateSystem')) 
     327                    TimeCoordinateSystem.toXML(definitionMember,frag) 
     328                    superFrag.append(frag) 
     329                    csmlFrag.append(superFrag) 
     330                if isinstance(definitionMember,EngineeringCRS): 
     331                    superFrag=Element(GML('definitionMember')) 
     332                    frag=Element(GML('EngineeringCRS')) 
     333                    EngineeringCRS.toXML(definitionMember,frag) 
     334                    superFrag.append(frag) 
     335                    csmlFrag.append(superFrag) 
     336        return csmlFrag 
     337 
     338 
     339class UnitDefinitions(Dictionary): 
     340        #Class for csml:UnitDefinitions(gml:Dictionary) 
     341    def __init__(self,*args,**kwargs): 
     342        Dictionary.__init__(self,*args,**kwargs) 
     343    def fromXML(self,csmlFrag): 
     344        Dictionary.fromXML(self,csmlFrag) 
     345    def toXML(self,csmlFrag): 
     346        Dictionary.toXML(self,csmlFrag) 
     347        return csmlFrag 
     348 
     349class ReferenceSystemDefinitions(Dictionary): 
     350    def __init__(self,*args,**kwargs): 
     351        Dictionary.__init__(self,*args,**kwargs) 
     352    def fromXML(self,csmlFrag): 
     353        Dictionary.fromXML(self,csmlFrag) 
     354    def toXML(self,csmlFrag): 
     355        Dictionary.toXML(self,csmlFrag) 
     356        return csmlFrag 
     357 
     358class PhenomenonDefinitions(Dictionary): 
     359    def __init__(self,*args,**kwargs): 
     360        Dictionary.__init__(self,*args,**kwargs) 
     361    def fromXML(self,csmlFrag): 
     362        Dictionary.fromXML(self,csmlFrag) 
     363    def toXML(self,csmlFrag): 
     364        Dictionary.toXML(self,csmlFrag) 
    222365        return csmlFrag 
    223366 
     
    11981341        return csmlFrag 
    11991342 
    1200 class Definition(AbstractGML): 
    1201     #Class definition, restricts AbstractGML 
    1202     #gml:id is mandatory. 
    1203     def __init__(self,*args,**kwargs): 
    1204         AbstractGML.__init__(self,*args,**kwargs) 
    1205     def fromXML(self,csmlFrag): 
    1206         AbstractGML.fromXML(self,csmlFrag) 
    1207         #TO DO: how  best to handle this? 
    1208         if not hasattr(self,'id'): 
    1209             print 'gml:id mandatory value missing in ' + csmlFrag.tag 
    1210             sys.exit() 
    1211     def toXML(self,csmlFrag): 
    1212         csmlFrag=AbstractGML.toXML(self,csmlFrag) 
    1213         return csmlFrag 
     1343 
    12141344 
    12151345class TypedCategory: 
  • TI02-CSML/trunk/newparser/example.xml

    r654 r680  
    1717                                <gml:catalogSymbol codeSpace="http://ndg.nerc.ac.uk/units">psu</gml:catalogSymbol> 
    1818                        </gml:UnitDefinition> 
     19                </gml:definitionMember> 
     20        <gml:definitionMember> 
     21            <gml:UnitDefinition gml:id="psu2"> 
     22                <gml:description>Conventional practical salinity units 2.</gml:description> 
     23                <gml:name>practical salinity units 2</gml:name> 
     24                <gml:quantityType>sea water salinity 2</gml:quantityType> 
     25                <gml:catalogSymbol codeSpace="http://ndg.nerc.ac.uk/units">psu2</gml:catalogSymbol> 
     26            </gml:UnitDefinition> 
    1927                </gml:definitionMember> 
    2028        </UnitDefinitions> 
  • TI02-CSML/trunk/newparser/test.py

    r678 r680  
    3939############################################################################## 
    4040# 1. Test parsing from CSML file 
    41 #tree = ElementTree(file='example.xml') 
     41tree = ElementTree(file='example.xml') 
    4242#tree = ElementTree(file='/home/users/domlowe/CSML/Coapec/Coapec.v2.xml') 
    43 tree = ElementTree(file='era40gridseries.xml') 
     43#tree = ElementTree(file='era40gridseries.xml') 
    4444dataset = Dataset() 
    4545dataset.fromXML(tree.getroot()) 
Note: See TracChangeset for help on using the changeset viewer.