StructureFilter_test

#!/usr/bin/python

#   Python script that communicates with the structure filter web service at EMBL
#   WSDL: http://structurefilter.embl.de/webservice/structureFilter.wsdl
#   By Kate Gould (gould@embl.de)

#   For this script to work the latest unofficial release of the ZSI SOAP toolkit ie ZSI-2.1_a1 
#   (available at http://sourceforge.net/project/showfiles.php?group_id=26590 on 19.04.09) is a prerequisite 
#   since this handles HTTP Keep-alive connections which is crucial where the request/response time may take longer than expected
#   (which may be the case for very long query sequences eg. TITIN_HUMAN)

#   attached imported client stub modules(ie StructureFilter_client.py, StructureFilter_server.py, StructureFilter_types.py)
#   generated via ZSI wsdl2py command:
#   wsdl2py http://structurefilter.embl.de/webservice/structureFilter.wsdl

#   (Note: there is a client script available at: http://structurefilter.embl.de/webservice/structureFilter.wsdl
#   which comprehensively demonstrates by example the full functionality of the structure filter web-service.)

from StructureFilter_client import StructureFilterLocator, RunJobMsg, GetStatusMsg, GetResultMsg

from time import time, sleep 
from sys import exit

try:
    # Assume that everything will work, so start with a returnvalue of 0 / Ok
    returnvalue = 0
        
    filter = StructureFilterLocator().getStructureFilter()

    # example input values

    # identifier and sequence are MANDATORY input values

    # P04637 (p53_human)
    identifier = 'P04637'
        
    querySequence = 'MEEPQSDPSVEPPLSQETFSDLWKLLPENNVLSPLPSQAMDDLMLSPDDIEQWFTEDPGPDEAPRMPEAAPPVAPAPAAPTPAAPAPAPSWPLSSSVPSQKTYQGSYGFRLGFLHSGTAKSVTCTYSPALNKMFCQLAKTCPVQLWVDSTPPPGTRVRAMAIYKQSQHMTEVVRRCPHHERCSDSDGLAPPQHLIRVEGNLRVEYLDDRNTFRHSVVVPYEPPEVGSDCTTIHYNYMCNSSCMGGMNRRPILTIITLEDSSGNLLGRNSFEVRVCACPGRDRRTEEENLRKKGEPHHELPPGSTKRALPNNTSSSPQPKKKPLDGEYFTLQIRGRERFEMFRELNEALELKDAQAGKEPGGSRAHSSHLKSKKGQSTSRHKKLMFKTEGPDSD'
        
    # all the following input values are OPTIONAL

    # up to a max of 5 regular expressions may be specified.
    # if the specified regular expression matches an existing
    # ELM regular expression in the ELM database, this additional
    # information is specified in the output results

    regularExpression1 = 'Y..[MLIFV]'
    regularExpression2 = 'Y[CIFVLT]..'
    regularExpression3= '[PA][^P][ADEGHKMNPQRSTV]S[ACDEGHKMNQRSTVFYWIL]'
    regularExpression4 = 'ES[RK][FY][YST]FH[PS][IV][ES]D'
    regularExpression5 = '.S..F'
        
    regExList = []

    regExList.append(regularExpression1)
    regExList.append(regularExpression2)
    regExList.append(regularExpression3)
    regExList.append(regularExpression4)
    regExList.append(regularExpression5)
        
    # up to a max of 5 elm identifiers may be specified.
    # for further details on a list of ELM identifiers  use the getAllELMs method of the ELMdb webservice
    # (http://elm.eu.org/webservice/ELMdb.wsdl)
    elmIdentifierName1 = 'LIG_CtBP'
    elmIdentifierName2 = 'TRG_ENDOCYTIC_2'
    elmIdentifierName3 = 'mod_ck2_1'
    elmIdentifierName4 = 'LIG_CyCLIN_1'
    elmIdentifierName5 = 'LIG_MAPK_1'

    elmIdentifierList = []
        
    elmIdentifierList.append(elmIdentifierName1)
    elmIdentifierList.append(elmIdentifierName2)
    elmIdentifierList.append(elmIdentifierName3)
    elmIdentifierList.append(elmIdentifierName4)
    elmIdentifierList.append(elmIdentifierName5)
    
    # the following two inputs must have a value of 'yes' or 'no'
    # if unspecified, they both default to 'no'

    includeSecondaryStructureRecords = 'yes'
    includeAccessibilityRecords = 'yes'

    req = RunJobMsg()

    # setting the following two attributes is MANDATORY
    req._identifier = identifier
    req._querySequence = querySequence
        
    # setting the following four attributes is OPTIONAL
    req._regularExpression = regExList
    req._elmIdentifierName = elmIdentifierList
    
    req._includeSecondaryStructureRecords = includeSecondaryStructureRecords 
    req._includeAccessibilityRecords = includeAccessibilityRecords

    msg = filter.RunJob(req)

    jobIdentifier = msg._JobIdentifier
    
    status = ''
        
    # record current time
    currentTime = time()

    req = GetStatusMsg()
    req._JobIdentifier = msg._JobIdentifier

    # Polling for status
    # status is one of RUNNING/ABORTED/DONE
    while (not((status == 'DONE') | (status == 'ABORTED'))):
        
        sleep(5)
        status = filter.GetStatus(req)._Status
        timeNow = time()
            
        if ((timeNow - currentTime) > 300.0):
            print 'time limit of approx 5 mins for job to run exceeded'
            returnvalue = 2
            break
                
        if (returnvalue != 2) & (status == 'DONE'):

            # fetch the results

            req = GetResultMsg()
        
            # set the job identifier attribute
            req._JobIdentifier = msg._JobIdentifier

            predictions = filter.GetResult(req)

            # start processing the output results
            identifier = predictions._sequence._identifier

            if identifier != 'P04637':
                print "data error in value of sequence identifier.\n"
                returnvalue = 2

            if predictions._structureFilterRecord[0]._totalScorePValue != 0.0020625391843878309:
                print "data error in total score p-value field of first record of structureFilterRecord list.\n"
                returnvalue = 2

            if predictions._structureFilterRecord[1]._targetDomainStructure != 'd1olhd_':
                print "data error in target domain structure field of second record of structureFilterRecord list.\n"
                returnvalue = 2
                                
            if predictions._structureFilterRecord[2]._ELMIdentifier != 'LIG_SH2_STAT5':
                print "data error in ELM identifier field of third record of structureFilterRecord list.\n"
                returnvalue = 2

            if predictions._structureFilterRecord[3]._individualResidueValues[0]._secondaryStructure != 'loop':
                print "data error in secondary structure field of first record of individualResidueValues list of fourth record of structureFilterRecord list.\n"
                returnvalue = 2

            if (predictions.__dict__.has_key('_secondaryStructureRecord')):
                if len(predictions._secondaryStructureRecord) > 0:

                    if predictions._secondaryStructureRecord[0]._start != 319:
                        print "data error in start field of first record of secondaryStructureRecord list.\n"
                        returnvalue = 2
                    
                    if predictions._secondaryStructureRecord[1]._secondaryStructure != 'helix':
                        print "data error in secondary structure field of second record of secondaryStructureRecord list.\n"
                        returnvalue = 2

            if (predictions.__dict__.has_key('_accessibilityRecord')):
                if len(predictions._accessibilityRecord) > 0:

                    if predictions._accessibilityRecord[0]._position != 96:
                        print "data error in position field of first record of accessibilityRecord.\n"
                        returnvalue = 2

                    if predictions._accessibilityRecord[2]._accessibility != 0.27000000000000002:
                        print "data error in accessibility field of third record of accessibilityRecord.\n"
                        returnvalue = 2
                        
except:
    print "Failed to talk to Structure Filter service"
    returnvalue = 1

if returnvalue == 0:
    print "Everything worked fine"

exit(returnvalue)

##################################################
# file: StructureFilter_client.py
# 
# client stubs generated by "ZSI.generate.wsdl2python.WriteServiceModule"
#     /usr/bin/wsdl2py http://structurefilter.embl.de/webservice/structureFilter.wsdl
# 
##################################################

from StructureFilter_types import *
import urlparse, types
from ZSI.TCcompound import ComplexType, Struct
from ZSI import client
from ZSI.schema import GED, GTD
import ZSI

# Locator
class StructureFilterLocator:
    StructureFilter_address = "http://luna.embl.de:8080/axis2/services/StructureFilter"
    def getStructureFilterAddress(self):
        return StructureFilterLocator.StructureFilter_address
    def getStructureFilter(self, url=None, **kw):
        return StructureFilterBindingSOAP(url or StructureFilterLocator.StructureFilter_address, **kw)

# Methods
class StructureFilterBindingSOAP:
    def __init__(self, url, **kw):
        kw.setdefault("readerclass", None)
        kw.setdefault("writerclass", None)
        # no resource properties
        self.binding = client.Binding(url=url, **kw)
        # no ws-addressing

    # op: RunJob
    def RunJob(self, request, **kw):
        if isinstance(request, RunJobMsg) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://structureFilter.embl.de/StructureFilter/RunJob", **kw)
        # no output wsaction
        response = self.binding.Receive(RunJobResponseMsg.typecode)
        return response

    # op: GetStatus
    def GetStatus(self, request, **kw):
        if isinstance(request, GetStatusMsg) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://structureFilter.embl.de/StructureFilter/GetStatus", **kw)
        # no output wsaction
        response = self.binding.Receive(GetStatusResponseMsg.typecode)
        return response

    # op: GetResult
    def GetResult(self, request, **kw):
        if isinstance(request, GetResultMsg) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://structureFilter.embl.de/StructureFilter/GetResult", **kw)
        # no output wsaction
        response = self.binding.Receive(GetResultResponseMsg.typecode)
        return response

RunJobMsg = GED("http://structureFilter.embl.de/StructureFilter", "RunJob").pyclass

RunJobResponseMsg = GED("http://structureFilter.embl.de/StructureFilter", "RunJobResponse").pyclass

GetStatusMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetStatus").pyclass

GetStatusResponseMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetStatusResponse").pyclass

GetResultMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetResult").pyclass

GetResultResponseMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetResultResponse").pyclass

##################################################
# file: StructureFilter_server.py
#
# skeleton generated by "ZSI.generate.wsdl2dispatch.ServiceModuleWriter"
#      /usr/bin/wsdl2py http://structurefilter.embl.de/webservice/structureFilter.wsdl
#
##################################################

from ZSI.schema import GED, GTD
from ZSI.TCcompound import ComplexType, Struct
from StructureFilter_types import *
from ZSI.ServiceContainer import ServiceSOAPBinding

# Messages  
RunJobMsg = GED("http://structureFilter.embl.de/StructureFilter", "RunJob").pyclass

RunJobResponseMsg = GED("http://structureFilter.embl.de/StructureFilter", "RunJobResponse").pyclass

GetStatusMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetStatus").pyclass

GetStatusResponseMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetStatusResponse").pyclass

GetResultMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetResult").pyclass

GetResultResponseMsg = GED("http://structureFilter.embl.de/StructureFilter", "GetResultResponse").pyclass


# Service Skeletons
class StructureFilter(ServiceSOAPBinding):
    soapAction = {}
    root = {}

    def __init__(self, post='/axis2/services/StructureFilter', **kw):
        ServiceSOAPBinding.__init__(self, post)

    def soap_RunJob(self, ps, **kw):
        request = ps.Parse(RunJobMsg.typecode)
        return request,RunJobResponseMsg()

    soapAction['http://structureFilter.embl.de/StructureFilter/RunJob'] = 'soap_RunJob'
    root[(RunJobMsg.typecode.nspname,RunJobMsg.typecode.pname)] = 'soap_RunJob'

    def soap_GetStatus(self, ps, **kw):
        request = ps.Parse(GetStatusMsg.typecode)
        return request,GetStatusResponseMsg()

    soapAction['http://structureFilter.embl.de/StructureFilter/GetStatus'] = 'soap_GetStatus'
    root[(GetStatusMsg.typecode.nspname,GetStatusMsg.typecode.pname)] = 'soap_GetStatus'

    def soap_GetResult(self, ps, **kw):
        request = ps.Parse(GetResultMsg.typecode)
        return request,GetResultResponseMsg()

    soapAction['http://structureFilter.embl.de/StructureFilter/GetResult'] = 'soap_GetResult'
    root[(GetResultMsg.typecode.nspname,GetResultMsg.typecode.pname)] = 'soap_GetResult'

##################################################
# file: StructureFilter_types.py
#
# schema types generated by "ZSI.generate.wsdl2python.WriteServiceModule"
#    /usr/bin/wsdl2py http://structurefilter.embl.de/webservice/structureFilter.wsdl
#
##################################################

import ZSI
import ZSI.TCcompound
from ZSI.schema import LocalElementDeclaration, ElementDeclaration, TypeDefinition, GTD, GED

##############################
# targetNamespace
# http://structureFilter.embl.de/StructureFilter
##############################

class ns0:
    targetNamespace = "http://structureFilter.embl.de/StructureFilter"

    class SequenceType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://structureFilter.embl.de/StructureFilter"
        type = (schema, "SequenceType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns0.SequenceType_Def.schema
            TClist = [self.__class__.identifier_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), self.__class__.sequence_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._identifier = None
                    self._sequence = None
                    return
            Holder.__name__ = "SequenceType_Holder"
            self.pyclass = Holder


        class identifier_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "identifier"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","identifier")
                kw["aname"] = "_identifier"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_identifier_immutable_holder"





        class sequence_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "sequence"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","sequence")
                kw["aname"] = "_sequence"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_sequence_immutable_holder"




    class AccessibilityRecordType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://structureFilter.embl.de/StructureFilter"
        type = (schema, "AccessibilityRecordType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns0.AccessibilityRecordType_Def.schema
            TClist = [ZSI.TCnumbers.Iinteger(pname=(ns,"position"), aname="_position", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"accessibility"), aname="_accessibility", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"targetDomainStructure"), aname="_targetDomainStructure", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._position = None
                    self._accessibility = None
                    self._targetDomainStructure = None
                    return
            Holder.__name__ = "AccessibilityRecordType_Holder"
            self.pyclass = Holder

    class SecondaryStructureRecordType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://structureFilter.embl.de/StructureFilter"
        type = (schema, "SecondaryStructureRecordType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns0.SecondaryStructureRecordType_Def.schema
            TClist = [ZSI.TCnumbers.Iinteger(pname=(ns,"start"), aname="_start", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iinteger(pname=(ns,"end"), aname="_end", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"secondaryStructure"), aname="_secondaryStructure", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"targetDomainStructure"), aname="_targetDomainStructure", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._start = None
                    self._end = None
                    self._secondaryStructure = None
                    self._targetDomainStructure = None
                    return
            Holder.__name__ = "SecondaryStructureRecordType_Holder"
            self.pyclass = Holder

    class StructureFilterRecordType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://structureFilter.embl.de/StructureFilter"
        type = (schema, "StructureFilterRecordType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns0.StructureFilterRecordType_Def.schema
            TClist = [ZSI.TC.String(pname=(ns,"ELMIdentifier"), aname="_ELMIdentifier", minOccurs=1, maxOccurs=1, nillable=True, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"regularExpression"), aname="_regularExpression", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iinteger(pname=(ns,"start"), aname="_start", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TCnumbers.Iinteger(pname=(ns,"end"), aname="_end", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"accessibilityScore"), aname="_accessibilityScore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"accessibilityScorePValue"), aname="_accessibilityScorePValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"secondaryStructureScore"), aname="_secondaryStructureScore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"secondaryStructureScorePValue"), aname="_secondaryStructureScorePValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"totalScore"), aname="_totalScore", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"totalScorePValue"), aname="_totalScorePValue", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"targetDomainStructure"), aname="_targetDomainStructure", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"percentageIdentity"), aname="_percentageIdentity", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"benchmarkAssignment"), aname="_benchmarkAssignment", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("http://structureFilter.embl.de/StructureFilter","IndividualResidueValuesType",lazy=False)(pname=(ns,"individualResidueValues"), aname="_individualResidueValues", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._ELMIdentifier = None
                    self._regularExpression = None
                    self._start = None
                    self._end = None
                    self._accessibilityScore = None
                    self._accessibilityScorePValue = None
                    self._secondaryStructureScore = None
                    self._secondaryStructureScorePValue = None
                    self._totalScore = None
                    self._totalScorePValue = None
                    self._targetDomainStructure = None
                    self._percentageIdentity = None
                    self._benchmarkAssignment = None
                    self._individualResidueValues = []
                    return
            Holder.__name__ = "StructureFilterRecordType_Holder"
            self.pyclass = Holder

    class IndividualResidueValuesType_Def(ZSI.TCcompound.ComplexType, TypeDefinition):
        schema = "http://structureFilter.embl.de/StructureFilter"
        type = (schema, "IndividualResidueValuesType")
        def __init__(self, pname, ofwhat=(), attributes=None, extend=False, restrict=False, **kw):
            ns = ns0.IndividualResidueValuesType_Def.schema
            TClist = [ZSI.TCnumbers.Iinteger(pname=(ns,"position"), aname="_position", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"targetDomainStructure"), aname="_targetDomainStructure", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.Decimal(pname=(ns,"accessibility"), aname="_accessibility", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), ZSI.TC.String(pname=(ns,"secondaryStructure"), aname="_secondaryStructure", minOccurs=0, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            self.attribute_typecode_dict = attributes or {}
            if extend: TClist += ofwhat
            if restrict: TClist = ofwhat
            ZSI.TCcompound.ComplexType.__init__(self, None, TClist, pname=pname, inorder=0, **kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._position = None
                    self._targetDomainStructure = None
                    self._accessibility = None
                    self._secondaryStructure = None
                    return
            Holder.__name__ = "IndividualResidueValuesType_Holder"
            self.pyclass = Holder

    class RunJob_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "RunJob"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.RunJob_Dec.schema
            TClist = [ZSI.TC.String(pname=(ns,"identifier"), aname="_identifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), self.__class__.querySequence_Dec(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), self.__class__.regularExpression_Dec(minOccurs=0, maxOccurs=5, nillable=False, encoded=kw.get("encoded")), self.__class__.elmIdentifierName_Dec(minOccurs=0, maxOccurs=5, nillable=False, encoded=kw.get("encoded")), self.__class__.includeSecondaryStructureRecords_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), self.__class__.includeAccessibilityRecords_Dec(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","RunJob")
            kw["aname"] = "_RunJob"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._identifier = None
                    self._querySequence = None
                    self._regularExpression = []
                    self._elmIdentifierName = []
                    self._includeSecondaryStructureRecords = None
                    self._includeAccessibilityRecords = None
                    return
            Holder.__name__ = "RunJob_Holder"
            self.pyclass = Holder


        class querySequence_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "querySequence"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","querySequence")
                kw["aname"] = "_querySequence"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_querySequence_immutable_holder"





        class regularExpression_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "regularExpression"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","regularExpression")
                kw["aname"] = "_regularExpression"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_regularExpression_immutable_holder"





        class elmIdentifierName_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "elmIdentifierName"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","elmIdentifierName")
                kw["aname"] = "_elmIdentifierName"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_elmIdentifierName_immutable_holder"





        class includeSecondaryStructureRecords_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "includeSecondaryStructureRecords"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","includeSecondaryStructureRecords")
                kw["aname"] = "_includeSecondaryStructureRecords"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_includeSecondaryStructureRecords_immutable_holder"





        class includeAccessibilityRecords_Dec(ZSI.TC.String, LocalElementDeclaration):
            literal = "includeAccessibilityRecords"
            schema = "http://structureFilter.embl.de/StructureFilter"
            def __init__(self, **kw):
                kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","includeAccessibilityRecords")
                kw["aname"] = "_includeAccessibilityRecords"
                ZSI.TC.String.__init__(self, **kw)
                class IHolder(str): typecode=self
                self.pyclass = IHolder
                IHolder.__name__ = "_includeAccessibilityRecords_immutable_holder"




    class RunJobResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "RunJobResponse"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.RunJobResponse_Dec.schema
            TClist = [ZSI.TC.String(pname=(ns,"JobIdentifier"), aname="_JobIdentifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","RunJobResponse")
            kw["aname"] = "_RunJobResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._JobIdentifier = None
                    return
            Holder.__name__ = "RunJobResponse_Holder"
            self.pyclass = Holder

    class GetStatus_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "GetStatus"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.GetStatus_Dec.schema
            TClist = [ZSI.TC.String(pname=(ns,"JobIdentifier"), aname="_JobIdentifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","GetStatus")
            kw["aname"] = "_GetStatus"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._JobIdentifier = None
                    return
            Holder.__name__ = "GetStatus_Holder"
            self.pyclass = Holder

    class Status_Dec(ZSI.TC.String, ElementDeclaration):
        literal = "Status"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","Status")
            kw["aname"] = "_Status"
            class IHolder(str): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_Status_immutable_holder"
            ZSI.TC.String.__init__(self, **kw)

    class StatusDetails_Dec(ZSI.TC.String, ElementDeclaration):
        literal = "StatusDetails"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","StatusDetails")
            kw["aname"] = "_StatusDetails"
            class IHolder(str): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_StatusDetails_immutable_holder"
            ZSI.TC.String.__init__(self, **kw)

    class GetStatusResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "GetStatusResponse"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.GetStatusResponse_Dec.schema
            TClist = [GED("http://structureFilter.embl.de/StructureFilter","Status",lazy=False, isref=True)(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded")), GED("http://structureFilter.embl.de/StructureFilter","StatusDetails",lazy=False, isref=True)(minOccurs=0, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","GetStatusResponse")
            kw["aname"] = "_GetStatusResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._Status = None
                    self._StatusDetails = None
                    return
            Holder.__name__ = "GetStatusResponse_Holder"
            self.pyclass = Holder

    class GetResult_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "GetResult"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.GetResult_Dec.schema
            TClist = [ZSI.TC.String(pname=(ns,"JobIdentifier"), aname="_JobIdentifier", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","GetResult")
            kw["aname"] = "_GetResult"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._JobIdentifier = None
                    return
            Holder.__name__ = "GetResult_Holder"
            self.pyclass = Holder

    class GetResultResponse_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "GetResultResponse"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.GetResultResponse_Dec.schema
            TClist = [GTD("http://structureFilter.embl.de/StructureFilter","SequenceType",lazy=False)(pname=(ns,"sequence"), aname="_sequence", minOccurs=1, maxOccurs=1, nillable=False, typed=False, encoded=kw.get("encoded")), GTD("http://structureFilter.embl.de/StructureFilter","StructureFilterRecordType",lazy=False)(pname=(ns,"structureFilterRecord"), aname="_structureFilterRecord", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("http://structureFilter.embl.de/StructureFilter","SecondaryStructureRecordType",lazy=False)(pname=(ns,"secondaryStructureRecord"), aname="_secondaryStructureRecord", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded")), GTD("http://structureFilter.embl.de/StructureFilter","AccessibilityRecordType",lazy=False)(pname=(ns,"accessibilityRecord"), aname="_accessibilityRecord", minOccurs=0, maxOccurs="unbounded", nillable=False, typed=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","GetResultResponse")
            kw["aname"] = "_GetResultResponse"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._sequence = None
                    self._structureFilterRecord = []
                    self._secondaryStructureRecord = []
                    self._accessibilityRecord = []
                    return
            Holder.__name__ = "GetResultResponse_Holder"
            self.pyclass = Holder

    class FaultDescription_Dec(ZSI.TC.String, ElementDeclaration):
        literal = "FaultDescription"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","FaultDescription")
            kw["aname"] = "_FaultDescription"
            class IHolder(str): typecode=self
            kw["pyclass"] = IHolder
            IHolder.__name__ = "_FaultDescription_immutable_holder"
            ZSI.TC.String.__init__(self, **kw)

    class JobIdentifierFault_Dec(ZSI.TCcompound.ComplexType, ElementDeclaration):
        literal = "JobIdentifierFault"
        schema = "http://structureFilter.embl.de/StructureFilter"
        def __init__(self, **kw):
            ns = ns0.JobIdentifierFault_Dec.schema
            TClist = [GED("http://structureFilter.embl.de/StructureFilter","FaultDescription",lazy=False, isref=True)(minOccurs=1, maxOccurs=1, nillable=False, encoded=kw.get("encoded"))]
            kw["pname"] = ("http://structureFilter.embl.de/StructureFilter","JobIdentifierFault")
            kw["aname"] = "_JobIdentifierFault"
            self.attribute_typecode_dict = {}
            ZSI.TCcompound.ComplexType.__init__(self,None,TClist,inorder=0,**kw)
            class Holder:
                typecode = self
                def __init__(self):
                    # pyclass
                    self._FaultDescription = None
                    return
            Holder.__name__ = "JobIdentifierFault_Holder"
            self.pyclass = Holder

# end class ns0 (tns: http://structureFilter.embl.de/StructureFilter)