def getDataType(self,name): # added for Service class compatibility (called from JobFacade)
df = DataTypeFactory()
p = [p for p in self.parameters if p.name==name][0]
datatype_class = p.type.datatype.class_name
datatype_superclass = p.type.datatype.superclass_name
if (datatype_superclass in [None,""] ):
dt = df.newDataType(datatype_class)
else:
dt = df.newDataType(datatype_superclass, datatype_class)
return dt
def getType(self): # added for Service.Parameter
try:
return self._mobyleType
except AttributeError:
df = DataTypeFactory()
datatype_class = self.type.datatype.class_name
datatype_superclass = self.type.datatype.superclass_name
if (datatype_superclass in [None,""] ):
dt = df.newDataType(datatype_class)
else:
dt = df.newDataType(datatype_superclass, datatype_class)
self._mobyleType = MobyleType(dt)
return self._mobyleType
def parseType( typeNode , dataTypeFactory = None , out = False , context = None):
if not dataTypeFactory:
dataTypeFactory = DataTypeFactory()
try:
bioTypes = typeNode.findall( "./biotype" )
bioTypes = [ bt.text for bt in bioTypes ]
except IndexError :
bioTypes = None
try:
card = typeNode.find( "./type/card" ).text
try:
min , max = card.split(",")
except ValueError:
if len( card ) == 2:
min = max = card
else:
raise ParserError , "invalid card: %s .the card element must be a string of 2 integer or \"n\" separate by a comma : "% card
try:
min = int( min )
except ValueError :
if min != "n":
raise ParserError , "invalid card: %s .the card element must be a string of 2 integer or \"n\" separate by a comma : "% card
try:
max = int( max )
except ValueError :
if max != "n":
raise ParserError , "invalid card: %s .the card element must be a string of 2 integer or \"n\" separate by a comma : "% card
card = ( min , max )
except AttributeError :
card = ( 1 , 1 )
try:
superKlass = typeNode.find( "./datatype/superclass" ).text
except AttributeError:
superKlass = None
try:
klass = typeNode.find( "./datatype/class" ).text
except AttributeError:
if superKlass is None :
raise ParserError , typeNode.find( "./name" ).text + " must have either a \"class\" element either a \"class\" and \"superclass\" element"
else:
raise ParserError , typeNode.find( "./name" ).text +" if the \"superclass\" is specified the the \"class\" element must be also specified"
try:
if superKlass:
dataType = dataTypeFactory.newDataType( superKlass , xmlName = klass )
else:
dataType = dataTypeFactory.newDataType( klass )
except MobyleError , err :
raise ParserError , err
def testsetInputDataFile( self ):
dtf = DataTypeFactory()
self.dataType1 = dtf.newDataType( 'Text' )
dataFile = {
'paramName' : "in_param_file",
'File' : ( 'foo.ori' , 'beautiful.format' , 234 ) ,
'fmtProgram' : 'squizz',
'formattedFile': ( 'foo.reformat' , 'wonderful.format' , 432 ) ,
}
self.jobState.setInputDataFile( dataFile[ 'paramName' ] ,
dataFile[ 'File' ],
dataFile[ 'fmtProgram' ] ,
dataFile[ 'formattedFile' ],
)
self.jobState.commit()
tree = etree.parse( os.path.join( os.path.join( self.jobDir , 'index.xml') ))
root = tree.getroot()
param = root.xpath( 'data/input/parameter[ name = "'+ dataFile[ 'paramName' ] + '" ]')[0]
self.assertEqual( param.find( 'name' ).text , dataFile[ 'paramName' ] )
def set_value(self, parameter_name, value=None, src=None, srcFileName=None):
wf_parameter = [p for p in self.workflow.parameters if p.name==parameter_name][0]
if value is not None:
log.debug("setting %s parameter value to %s" %(parameter_name, value))
elif src is not None:
log.debug("copying %s parameter value from %s/%s" %(parameter_name, src,srcFileName))
else:
log.error("no VALUE or SOURCE URL specified for %s parameter." % parameter_name)
""" set a parameter value """
self.parameters[parameter_name] = value
self.parameters[parameter_name + '.src'] = src
self.parameters[parameter_name + '.srcFileName'] = srcFileName
if value and value==wf_parameter.vdef:
log.debug("setting %s parameter value to default value %s" %(parameter_name, wf_parameter.vdef))
return
# save input value in a file
# link this file from the JobState xml
datatype_class = wf_parameter.type.datatype.class_name
datatype_superclass = wf_parameter.type.datatype.superclass_name
df = DataTypeFactory()
if (datatype_superclass in [None,""] ):
dt = df.newDataType(datatype_class)
else:
dt = df.newDataType(datatype_superclass, datatype_class)
mt = MobyleType(dt)
p = Parameter(mt, name=parameter_name)
p._isout = wf_parameter.isout
if dt.isFile():
file_name = parameter_name+'.data'
if src:
src = DataProvider.get(src)
file_name, size = mt.toFile( value , self , file_name, src , srcFileName )
if not(wf_parameter.isout):
self.jobState.setInputDataFile(parameter_name, (file_name, size, None))
else:
self.jobState.setOutputDataFile(parameter_name, [(file_name, size, None)])
else:
if not(wf_parameter.isout):
self.jobState.setInputDataValue(parameter_name, value)
else:
raise NotImplementedError() # so far Mobyle does not manage non-file outputs
self.jobState.commit()
def setUp(self):
"""
setting up the configuration for the test, including:
- test configuration that does not check dns or try to send confirmation emails
- test session email
"""
self.cfg = Mobyle.ConfigManager.Config()
shutil.rmtree(self.cfg.test_dir, ignore_errors=True)
os.makedirs(self.cfg.test_dir)
self.sessionKey = "Q12345678901234"
self.sessionDir = os.path.join( self.cfg.test_dir , self.sessionKey )
os.makedirs( self.sessionDir )
self.email = '*****@*****.**'
self.passwd = 'dummypass'
self.actkey = 'dummykey'
self.xmlSourcePath = os.path.join( DATADIR , 'session_test.xml')
self.sessionPath = os.path.join( self.sessionDir , Session.FILENAME )
self.dataID = [ "f835ddf28cb6aa776a41d7c71ec9cb5a.out" , "16bd6f89e732eb7cb0bbc13c65d202d3.aln" ]
dtf = DataTypeFactory()
dataType1 = dtf.newDataType( 'Sequence' )
mobyleType1 = MobyleType( dataType1 , bioTypes = [ 'Protein' , 'Nucleic' ] , dataFormat = 'SWISSPROT' )
dataType2 = dtf.newDataType( 'Alignment' )
mobyleType2 = MobyleType( dataType2 , dataFormat = 'PHYLIPI' )
self.datas = [ {'dataName' : 'f835ddf28cb6aa776a41d7c71ec9cb5a.out' ,
'userName' : 'golden.out' ,
'size' : 4410 ,
'Type' : mobyleType1 ,
'dataBegin' : 'ID 104K_THEPA Reviewed; 924' ,
'inputModes' : [ 'result' ] ,
'producedBy' : [ 'file://tmp/mobyle/results/dnadist/G25406684175968' ] ,
'usedBy' : []
} ,
{'dataName' : '16bd6f89e732eb7cb0bbc13c65d202d3.aln' ,
'userName' : 'clustal.aln' ,
'size' : 90044 ,
'Type' : mobyleType2 ,
'dataBegin' : ' 47 1618\nF_75 ---------------------------' ,
'inputModes' : [ 'upload' , 'paste' ] ,
'producedBy' : [] ,
'usedBy' : [ 'file://tmp/mobyle/results/dnadist/G25406684175968' ,
'file://tmp/mobyle/results/dnadist/X25423048243999' ]
}
]
self.jobID = [ "file://tmp/mobyle/results/dnadist/X25423048243999" ,
"file://tmp/mobyle/results/dnadist/G25406684175968" ]
self.jobs = [ {'jobID' : 'file://tmp/mobyle/results/dnadist/X25423048243999' ,
'userName' : 'mon programme a moi' ,
'programName' : 'prog 1' ,
'status' : Mobyle.Status.Status( code = 6 ) , #killed
'date' : (2008, 11, 20, 12, 0, 0, 3, 325, -1) ,
'dataProduced': [] ,
'dataUsed' : ['16bd6f89e732eb7cb0bbc13c65d202d3.aln'] ,
} ,
{'jobID' : 'file://tmp/mobyle/results/dnadist/G25406684175968' ,
'userName' : 'file://tmp/mobyle/results/dnadist/G25406684175968' ,
'programName' : 'dnadist' ,
'status' : Mobyle.Status.Status( code = 3 ) , #running
'date' : (2008, 11, 19, 10, 50, 33, 2, 324, -1) ,
'dataProduced': ['f835ddf28cb6aa776a41d7c71ec9cb5a.out'] ,
'dataUsed' : ['16bd6f89e732eb7cb0bbc13c65d202d3.aln'] ,
}
]
def _faketype(self, mtype):
dtf = DataTypeFactory()
dtyp = dtf.newDataType(mtype)
return MobyleType(dtyp, None)
