def extractStep(self):
listIds = {}
smallMolID = "none"
for item in self.inputListID.get():
if hasattr(item, "_iteractsWithPDBId"):
tokens = item._iteractsWithPDBId.get().split(";")
for token in tokens:
pdbId = token.strip()
if not pdbId in listIds:
listIds[pdbId] = []
chemId = item.getDbId()
if hasattr(item, "_PDBChemId"):
chemId = item._PDBChemId.get()
smallMolID = "pdbchem"
listIds[pdbId].append(chemId)
outputDatabaseID = SetOfDatabaseID().create(path=self._getPath(),
suffix='PDBs')
for pdbId in listIds:
pdb = DatabaseID()
pdb.setDatabase("pdb")
pdb.setDbId(pdbId)
pdb._pdbId = pwobj.String(pdbId)
pdb._PDBLink = pwobj.String("https://www.rcsb.org/structure/%s" %
pdbId)
aux = " ; ".join(listIds[pdbId])
if smallMolID == "none":
pdb._interactsWithChemId = pwobj.String(aux)
elif smallMolID == "pdbchem":
pdb._interactsWithPDBChemId = pwobj.String(aux)
outputDatabaseID.append(pdb)
self._defineOutputs(outputPDBs=outputDatabaseID)
self._defineSourceRelation(self.inputListID, outputDatabaseID)
def importStep(self):
if not self.multiple.get():
copyFile(self.filePath.get(),self._getPath(os.path.split(self.filePath.get())[1]))
fh = open(self.filePath.get())
for line in fh.readlines():
tokens = line.split(',')
if len(tokens)==2:
fhSmile = open(self._getExtraPath(tokens[0].strip()+".smi"),'w')
fhSmile.write(tokens[1].strip()+"\n")
fhSmile.close()
else:
for filename in glob.glob(os.path.join(self.filesPath.get(), self.filesPattern.get())):
fnSmall = self._getExtraPath(os.path.split(filename)[1])
copyFile(filename, fnSmall)
outputSmallMolecules = SetOfSmallMolecules().create(path=self._getPath(),suffix='SmallMols')
for fnSmall in glob.glob(self._getExtraPath("*")):
smallMolecule = SmallMolecule(smallMolFilename=fnSmall)
if not fnSmall.endswith('.mae') and not fnSmall.endswith('.maegz'):
fnRoot = os.path.splitext(os.path.split(fnSmall)[1])[0]
fnOut = self._getExtraPath("%s.png" % fnRoot)
args = Plugin.getPluginHome('utils/rdkitUtils.py') + " draw %s %s" % (fnSmall, fnOut)
try:
Plugin.runRDKit(self, "python3", args)
smallMolecule._PDBLigandImage = pwobj.String(fnOut)
except:
smallMolecule._PDBLigandImage = pwobj.String("Not available")
outputSmallMolecules.append(smallMolecule)
self._defineOutputs(outputSmallMols=outputSmallMolecules)
def __init__(self, confs={}, **kwargs):
pwobj.OrderedObject.__init__(self, **kwargs)
self.config = ProjectConfig()
# Store the current view selected by the user
self.currentProtocolsView = pwobj.String()
# Store the color mode: 0= Status, 1=Labels, ...
self.colorMode = pwobj.Integer(ProjectSettings.COLOR_MODE_STATUS)
self.nodeList = NodeConfigList(
) # Store graph nodes positions and other info
self.labelsList = LabelsList() # Label list
self.mapper = None # This should be set when load, or write
self.runsView = pwobj.Integer(1) # by default the graph view
self.readOnly = pwobj.Boolean(False)
self.runSelection = pwobj.CsvList(int) # Store selected runs
self.dataSelection = pwobj.CsvList(int) # Store selected runs
# Some extra settings stored, now mainly used
# from the webtools
# Time when the project was created
self.creationTime = pwobj.String(dt.datetime.now())
# Number of days that this project is active
# if None, the project will not expire
# This is used in webtools where a limited time
# is allowed for each project
self.lifeTime = pwobj.Integer()
# Set a disk quota for the project (in Gb)
# if None, quota is unlimited
self.diskQuota = pwobj.Integer()
def __init__(self, **kwargs):
Volume.__init__(self, **kwargs)
self._acquisition = None
self._tsId = pwobj.String(kwargs.get('tsId', None))
self._tomoPointer = pwobj.Pointer(objDoStore=False)
self._tomoId = pwobj.Integer()
self._tomoName = pwobj.String()
def createOutput(self):
smallDict = {}
for small in self.inputLibrary.get():
fnSmall = small.getFileName()
fnBase = os.path.splitext(os.path.split(fnSmall)[1])[0]
if not fnBase in smallDict:
smallDict[fnBase]=fnSmall
grid = self.inputGrid.get()
fnStruct = grid.structureFile.get()
if hasattr(grid,"bindingSiteScore"):
bindingSiteScore = grid.bindingSiteScore.get()
else:
bindingSiteScore = None
if hasattr(grid,"bindingSiteDScore"):
bindingSiteDScore = grid.bindingSiteDScore.get()
else:
bindingSiteDScore = None
smallList = []
posesDir = self._getExtraPath('poses')
makePath(posesDir)
fhCsv = open(self._getPath('job_pv.csv'))
fnPv = self._getPath('job_pv.maegz')
i = 0
for line in fhCsv.readlines():
if i>1:
tokens = line.split(',')
small = SmallMolecule(smallMolFilename=smallDict[tokens[0]])
small.dockingScore = pwobj.Float(tokens[1])
small.ligandEfficiency = pwobj.Float(tokens[2])
small.ligandEfficiencySA = pwobj.Float(tokens[3])
small.ligandEfficiencyLn = pwobj.Float(tokens[4])
small.poseFile = pwobj.String("%d@%s"%(i,fnPv))
small.structFile = pwobj.String(fnStruct)
if bindingSiteScore:
small.bindingSiteScore = pwobj.Float(bindingSiteScore)
if bindingSiteDScore:
small.bindingSiteDScore = pwobj.Float(bindingSiteDScore)
smallList.append(small)
i+=1
fhCsv.close()
idxSorted=sortDockingResults(smallList)
outputSet = SetOfSmallMolecules().create(path=self._getPath())
for idx in idxSorted:
small=smallList[idx]
outputSet.append(small)
self._defineOutputs(outputSmallMolecules=outputSet)
self._defineSourceRelation(self.inputGrid, outputSet)
self._defineSourceRelation(self.inputLibrary, outputSet)
mae = SchrodingerPoses(filename=fnPv)
self._defineOutputs(outputPoses=mae)
self._defineSourceRelation(self.inputGrid, mae)
self._defineSourceRelation(self.inputLibrary, mae)
def __init__(self, location=None, **kwargs):
"""
Params:
:param location: Could be a valid location: (index, filename)
or filename
"""
EdBaseObject.__init__(self, **kwargs)
# Image location is composed by an index and a filename
self._index = pwobj.Integer(0)
self._filename = pwobj.String()
# Detector distance of this image
self._distance = pwobj.Float()
# Where oscillation starts and its range
self._oscStart = pwobj.Float()
self._oscRange = pwobj.Float()
# Beam center (in pixels)
self._beamCenterX = pwobj.Float()
self._beamCenterY = pwobj.Float()
# Exposure time (in seconds)
self._exposureTime = pwobj.Float()
# TwoTheta
self._twoTheta = pwobj.Float()
# Pixel size of the image (in millimeters)
self._pixelSizeX = pwobj.Float()
self._pixelSizeY = pwobj.Float()
# Dimensions of images in this set (number of pixels)
self._dimX = pwobj.Integer()
self._dimY = pwobj.Integer()
# Wavelength
self._wavelength = pwobj.Float()
# Detector type
self._detector = Detector()
# Experiment time
self._collectionTime = pwobj.String()
# Add parameter to state if the image should be ignored in processing
self._ignore = pwobj.Boolean()
# Add information about goniometer rotation axis relative to image
self._rotX = pwobj.Float()
self._rotY = pwobj.Float()
self._rotZ = pwobj.Float()
if location:
self.setLocation(location)
def __init__(self,
filename=None,
poses=None,
ctfs=None,
dim=None,
samplingRate=None,
**kwargs):
EMObject.__init__(self, **kwargs)
self.filename = pwobj.String(filename)
self.poses = pwobj.String(poses)
self.ctfs = pwobj.String(ctfs)
self.samplingRate = pwobj.Float(samplingRate)
self.dim = pwobj.Integer(dim)
def __init__(self, text=None, value=None, icon=None, tag=None, **kwargs):
"""Constructor for the Menu config item.
Arguments:
text: text to be displayed
value: internal value associated with the item.
icon: display an icon with the item
tag: put some tags to items
**args: pass other options to base class.
"""
self.text = pwobj.String(text)
self.value = pwobj.String(value)
self.icon = pwobj.String(icon)
self.tag = pwobj.String(tag)
self.childs = pwobj.List()
self.openItem = pwobj.Boolean(kwargs.get('openItem', False))
def __init__(self, **kwargs):
MockObject.__init__(self, **kwargs)
self._micrographPointer = pwobj.Pointer(objDoStore=False)
self._x = pwobj.Integer(kwargs.get('x', None))
self._y = pwobj.Integer(kwargs.get('y', None))
self._micId = pwobj.Integer()
self._micName = pwobj.String()
def _storeCreationTime(self, creationTime):
""" Store the creation time in the project db. """
# Store creation time
creation = pwobj.String(objName=PROJECT_CREATION_TIME)
creation.set(creationTime)
self.mapper.insert(creation)
self.mapper.commit()
def create(self, runsView=1, readOnly=False, hostsConf=None,
protocolsConf=None):
"""Prepare all required paths and files to create a new project.
Params:
hosts: a list of configuration hosts associated to this projects (class ExecutionHostConfig)
"""
# Create project path if not exists
pwutils.path.makePath(self.path)
os.chdir(self.path) # Before doing nothing go to project dir
self._cleanData()
print "Creating project at: ", os.path.abspath(self.dbPath)
# Create db through the mapper
self.mapper = self.createMapper(self.dbPath)
creation = pwobj.String(objName='CreationTime') # Store creation time
creation.set(dt.datetime.now())
self.mapper.insert(creation)
self.mapper.commit()
# Load settings from .conf files and write .sqlite
self.settings = pwconfig.ProjectSettings()
self.settings.setRunsView(runsView)
self.settings.setReadOnly(readOnly)
self.settings.write(self.settingsPath)
# Create other paths inside project
for p in self.pathList:
pwutils.path.makePath(p)
self._loadHosts(hostsConf)
self._loadProtocols(protocolsConf)
def searchStep(self):
outputDatabaseID = SetOfDatabaseID().create(path=self._getPath())
for item in self.inputListID.get():
newItem = DatabaseID()
newItem.copy(item)
newItem._uniprotId = pwobj.String("Not available")
newItem._uniprotLink = pwobj.String("Not available")
pdbId = item._pdbId.get()
print("Processing %s" % pdbId)
urlId = "https://www.rcsb.org/pdb/rest/das/pdb_uniprot_mapping/alignment?query=%s" % pdbId
if hasattr(item, "_chain"):
urlId += "." + item._chain.get().upper()
fnXml = self._getExtraPath("%s.xml" % pdbId)
if not os.path.exists(fnXml):
print("Fetching uniprot: %s" % urlId)
for i in range(3):
try:
urllib.request.urlretrieve(urlId, fnXml)
break
except: # The library raises an exception when the web is not found
pass
if os.path.exists(fnXml):
try:
tree = ET.parse(fnXml)
# print(ET.tostring(tree, pretty_print=True))
uniprotId = None
for child in tree.getroot().iter():
if child.tag.endswith("alignObject"):
if child.attrib['dbSource'] == "UniProt":
uniprotId = child.attrib['dbAccessionId']
break
if uniprotId:
newItem._uniprotId = pwobj.String(uniprotId)
newItem._uniprotLink = pwobj.String(
"https://www.uniprot.org/uniprot/%s" % uniprotId)
except:
print(" Cannot parse the Uniprot XML: %s" % fnXml)
outputDatabaseID.append(newItem)
self._defineOutputs(outputUniprot=outputDatabaseID)
self._defineSourceRelation(self.inputListID, outputDatabaseID)
def searchStep(self):
outputDatabaseID = SetOfDatabaseID().create(path=self._getPath())
fnList = []
for item in self.inputListID.get():
newItem = DatabaseID()
newItem.copy(item)
newItem._uniprotFile = pwobj.String("Not available")
newItem._unitprotSeqLength = pwobj.Integer(-1)
uniprotId = item._uniprotId.get()
print("Processing %s" % uniprotId)
urlId = "https://www.uniprot.org/uniprot/%s.fasta" % uniprotId
fnFasta = self._getExtraPath("%s.fasta" % uniprotId)
if not os.path.exists(fnFasta):
print("Fetching uniprot: %s" % urlId)
for i in range(3):
try:
urllib.request.urlretrieve(urlId, fnFasta)
if not fnFasta in fnList:
fnList.append(fnFasta)
break
except: # The library raises an exception when the web is not found
pass
if os.path.exists(fnFasta):
newItem._uniprotFile = pwobj.String(fnFasta)
newItem._unitprotSeqLength = pwobj.Integer(
sequenceLength(fnFasta))
outputDatabaseID.append(newItem)
fnAll = self._getPath("sequences.fasta")
with open(fnAll, 'w') as outfile:
for fname in fnList:
with open(fname) as infile:
for line in infile:
outfile.write(line)
outfile.write('\n\n')
seqFile = ProteinSequenceFile()
seqFile.setFileName(fnAll)
self._defineOutputs(outputUniprot=outputDatabaseID)
self._defineSourceRelation(self.inputListID, outputDatabaseID)
self._defineOutputs(outputSequence=seqFile)
self._defineSourceRelation(self.inputListID, seqFile)
def show(self, form, *params):
attrsList = self.getInputAttributes(form)
finalAttrsList = []
for i in attrsList:
finalAttrsList.append(pwobj.String(i))
provider = ListTreeProviderString(finalAttrsList)
dlg = dialog.ListDialog(form.root, "Filter set", provider,
"Select one of the attributes")
form.setVar('rankingField', dlg.values[0].get())
def test_String(self):
value = 'thisisastring'
s = pwobj.String(value)
self.assertEqual(value, s.get())
self.assertEqual(s.hasValue(), True)
s2 = pwobj.String()
# None value is considered empty
self.assertTrue(s2.empty(), "s2 string should be empty if None")
s2.set(' ')
# Only spaces is also empty
self.assertTrue(s2.empty(), "s2 string should be empty if only spaces")
s2.set('something')
# No empty after some value
self.assertFalse(s2.empty(),
"s2 string should not be empty after value")
now = dt.datetime.now()
s.set(now)
self.assertEqual(now, s.datetime())
def _createOutputMovie(self, movie):
""" Overwrite this function to store the Relion's specific
Motion model coefficients.
"""
m = ProtAlignMovies._createOutputMovie(self, movie)
# Load local motion values only if the patches are more than one
if self.patchX.get() * self.patchY.get() > 1:
table = md.Table(fileName=self._getMovieExtraFn(movie, '.star'),
tableName='local_motion_model')
coeffs = [row.rlnMotionModelCoeff for row in table]
m._rlnMotionModelCoeff = pwobj.String(json.dumps(coeffs))
return m
def __init__(self, **kwargs):
pwobj.OrderedObject.__init__(self, **kwargs)
self.fullName = pwobj.String(kwargs.get('fullName', None))
self.organization = pwobj.String(kwargs.get('organization', None))
self.email = pwobj.String(kwargs.get('email', None))
self.subscription = pwobj.String(kwargs.get('subscription', None))
self.country = pwobj.String(kwargs.get('country', None))
self.version = pwobj.String(kwargs.get('version', None))
self.platform = pwobj.String(kwargs.get('platform', None))
def constructOutput(self, fnTxt):
fnDir, fnResults = os.path.split(fnTxt)
tokens = fnResults.split('-')
if len(tokens) > 1:
subset = tokens[1].split('.')[0]
else:
subset = ""
outputSet = SetOfDatabaseID.create(path=self._getPath(), suffix=subset)
for line in open(fnTxt, "r"):
line = line.strip()
if line == "":
continue
elif line.startswith("# Structural equivalences"):
break
elif line.startswith("#"):
continue
else:
tokens = line.split()
pdbId = DatabaseID()
tokens2 = tokens[1].split('-')
pdbId.setDatabase("pdb")
pdbId.setDbId(tokens[1])
pdbId._pdbId = pwobj.String(tokens2[0])
if len(tokens2) > 1:
pdbId._chain = pwobj.String(tokens2[1])
pdbId._PDBLink = pwobj.String(
"https://www.rcsb.org/structure/%s" % tokens2[0])
pdbId._DaliZscore = pwobj.Float(float(tokens[2]))
pdbId._DaliRMSD = pwobj.Float(float(tokens[3]))
pdbId._DaliSuperpositionLength = pwobj.Integer(int(tokens[4]))
pdbId._DaliSeqLength = pwobj.Integer(int(tokens[5]))
pdbId._DaliSeqIdentity = pwobj.Float(float(tokens[6]))
pdbId._DaliDescription = pwobj.String(" ".join(tokens[7:]))
outputSet.append(pdbId)
outputDict = {'outputDatabaseIds%s' % subset: outputSet}
self.protocol._defineOutputs(**outputDict)
self.protocol._defineSourceRelation(self.protocol.inputStructure,
outputSet)
def __init__(self, location=None, **kwargs):
"""
Params:
:param location: Could be a valid location: (index, filename)
or filename
"""
MockObject.__init__(self, **kwargs)
# Image location is composed by an index and a filename
self._index = pwobj.Integer(0)
self._filename = pwobj.String()
self._samplingRate = pwobj.Float()
self._ctfModel = None
self._acquisition = None
if location:
self.setLocation(location)
def _loadInputCoords(self, micDict):
""" Load coordinates from the input streaming.
"""
# TODO: this takes for ever if you are NOT
# doing streaming and have several thousands of mics
# so I add a counter to keep the user entertained
import sys
a = datetime.now()
counter = 1
coordsFn = self.getCoords().getFileName()
self.debug("Loading input db: %s" % coordsFn)
coordSet = emobj.SetOfCoordinates(filename=coordsFn)
# FIXME: Temporary to avoid loadAllPropertiesFail
coordSet._xmippMd = pwobj.String()
coordSet.loadAllProperties()
micList = dict() # To store a dictionary with mics with coordinates
for micKey, mic in micDict.items():
if counter % 50 == 0:
b = datetime.now()
print(b - a, 'reading coordinates for mic number',
"%06d" % counter)
sys.stdout.flush() # force buffer to print
counter += 1
micId = mic.getObjId()
coordList = []
self.debug("Loading coords for mic: %s (%s)" % (micId, micKey))
for coord in coordSet.iterItems(where='_micId=%s' % micId):
# TODO: Check performance penalty of using this clone
coordList.append(coord.clone())
self.debug("Coords found: %s" % len(coordList))
if coordList:
self.coordDict[micId] = coordList
micList[micKey] = mic
self.coordsClosed = coordSet.isStreamClosed()
coordSet.close()
self.debug("Coords are closed? %s" % self.coordsClosed)
self.debug("Closed db.")
return micList
def createOutput(self):
def parseEvalLog(fnLog):
fh = open(fnLog)
state = 0
for line in fh.readlines():
if state == 0 and line.startswith("SiteScore"):
state = 1
elif state == 1:
# SiteScore size Dscore volume exposure enclosure contact phobic philic balance don/acc
tokens = [float(x) for x in line.split()]
return tokens
return None
fnBinding = self._getPath("job_out.maegz")
fnStructure = self.inputStructure.get().getFileName()
if os.path.exists(fnBinding):
setOfBindings = SetOfBindingSites().create(path=self._getPath())
for fn in glob.glob(self._getPath("job_site_*_eval.log")):
score, size, dscore, volume, exposure, enclosure, contact, phobic, philic, balance, donacc = parseEvalLog(
fn)
n = fn.split("job_site_")[1].replace("_eval.log", "")
bindingSite = BindingSite(bindingSiteFilename="%s@%s" %
(n, fnBinding))
bindingSite.score = pwobj.Float(score)
bindingSite.size = pwobj.Float(size)
bindingSite.dscore = pwobj.Float(dscore)
bindingSite.volume = pwobj.Float(volume)
bindingSite.exposure = pwobj.Float(exposure)
bindingSite.enclosure = pwobj.Float(enclosure)
bindingSite.contact = pwobj.Float(contact)
bindingSite.phobic = pwobj.Float(phobic)
bindingSite.phobic = pwobj.Float(phobic)
bindingSite.philic = pwobj.Float(philic)
bindingSite.balance = pwobj.Float(balance)
bindingSite.donacc = pwobj.Float(donacc)
bindingSite.structureFile = pwobj.String(fnStructure)
setOfBindings.append(bindingSite)
self._defineOutputs(outputSetBindingSites=setOfBindings)
self._defineSourceRelation(self.inputStructure, setOfBindings)
mae = SchrodingerBindingSites(filename=fnBinding)
self._defineOutputs(outputBindingSites=mae)
self._defineSourceRelation(self.inputStructure, mae)
def _createOutputMovie(self, movie):
""" Overwrite this function to store the Relion's specific
Motion model coefficients.
"""
m = ProtAlignMovies._createOutputMovie(self, movie)
# Load local motion values only if the patches are more than one
if self.patchX.get() > 2 and self.patchY.get() > 2:
try:
table = md.Table(fileName=self._getMovieExtraFn(
movie, '.star'),
tableName='local_motion_model')
coeffs = [row.rlnMotionModelCoeff for row in table]
except:
print("Failed to parse local motion from: %s" %
os.path.abspath(self._getMovieExtraFn(movie, '.star')))
coeffs = [] # Failed to parse the local motion
m._rlnMotionModelCoeff = pwobj.String(json.dumps(coeffs))
return m
def show(self, form, *params):
protocol = form.protocol
try:
listOfChains, listOfResidues = self.getModelsChainsStep(protocol)
except Exception as e:
print("ERROR: ", e)
return
self.editionListOfChains(listOfChains)
finalChainList = []
for i in self.chainList:
finalChainList.append(pwobj.String(i))
provider = ListTreeProviderString(finalChainList)
dlg = dialog.ListDialog(
form.root, "Model chains", provider,
"Select one of the chains (model, chain, "
"number of chain residues)")
form.setVar('inputStructureChain', dlg.values[0].get())
def __init__(self, **kwargs):
pwobj.Object.__init__(self, **kwargs)
self.micId = pwobj.Integer(kwargs.get('micId', None))
self.micName = pwobj.String(kwargs.get('micName', None))
# list particle x coordinate
def _floatList(key):
fl = pwobj.CsvList(pType=float)
fl.set(kwargs.get(key, []))
return fl
self.x = _floatList('xCoord')
# list particle y coordinate
self.y = _floatList('yCoord')
# list particle defocus
self.defocus = _floatList('defocus')
# list particle defocus difference
self.defocusDiff = _floatList('defocusDiff')
self.stdev = pwobj.Float() # defocus stdev
self.n = pwobj.Integer() # number particles in the micrograph
def __init__(self, train_data_dir=None, patch_size=None, **kwargs):
EMObject.__init__(self, **kwargs)
self._train_data_dir = pwobj.String(train_data_dir)
self._patch_size = pwobj.Integer(patch_size)
def __init__(self, basedir=None, train_data_dir=None, **kwargs):
EMObject.__init__(self, **kwargs)
self._basedir = pwobj.String(basedir)
self._train_data_dir = pwobj.String(train_data_dir)
def __init__(self, **args):
pwobj.OrderedObject.__init__(self, **args)
self.logo = pwobj.String('scipion_logo_small.png')
# Do not store this object, unless we implement some kind of
# icon customization
self._objDoStore = False
def processMovieStep(self, movieDict, hasAlignment):
movie = emobj.Movie()
movie.setAcquisition(emobj.Acquisition())
if hasAlignment:
movie.setAlignment(emobj.MovieAlignment())
movie.setAttributesFromDict(movieDict,
setBasic=True,
ignoreMissing=True)
movieFolder = self._getOutputMovieFolder(movie)
movieFn = movie.getFileName()
movieName = basename(movieFn)
movieDoneFn = self._getMovieDone(movie)
if self.isContinued() and os.path.exists(movieDoneFn):
self.info("Skipping movie: %s, seems to be done" % movieFn)
return
# Clean old finished files
pwutils.cleanPath(movieDoneFn)
if self._filterMovie(movie):
pwutils.makePath(movieFolder)
pwutils.createLink(movieFn, join(movieFolder, movieName))
if movieName.endswith('bz2'):
newMovieName = movieName.replace('.bz2', '')
# We assume that if compressed the name ends with .mrc.bz2
if not exists(newMovieName):
self.runJob('bzip2',
'-d -f %s' % movieName,
cwd=movieFolder)
elif movieName.endswith('tbz'):
newMovieName = movieName.replace('.tbz', '.mrc')
# We assume that if compressed the name ends with .tbz
if not exists(newMovieName):
self.runJob('tar', 'jxf %s' % movieName, cwd=movieFolder)
elif movieName.endswith('.txt'):
# Support a list of frame as a simple .txt file containing
# all the frames in a raw list, we could use a xmd as well,
# but a plain text was choose to simply its generation
movieTxt = os.path.join(movieFolder, movieName)
with open(movieTxt) as f:
movieOrigin = os.path.basename(os.readlink(movieFn))
newMovieName = movieName.replace('.txt', '.mrcs')
ih = emlib.image.ImageHandler()
for i, line in enumerate(f):
if line.strip():
inputFrame = os.path.join(movieOrigin,
line.strip())
ih.convert(
inputFrame,
(i + 1, os.path.join(movieFolder,
newMovieName)))
else:
newMovieName = movieName
convertExt = self._getConvertExtension(newMovieName)
correctGain = self._doCorrectGain()
if convertExt or correctGain:
inputMovieFn = os.path.join(movieFolder, newMovieName)
if inputMovieFn.endswith('.em'):
inputMovieFn += ":ems"
if convertExt:
newMovieName = pwutils.replaceExt(newMovieName, convertExt)
else:
newMovieName = '%s_corrected.%s' % os.path.splitext(
newMovieName)
outputMovieFn = os.path.join(movieFolder, newMovieName)
# If the protocols wants Scipion to apply the gain, then
# there is no reason to convert, since we can produce the
# output in the format expected by the program. In some cases,
# the alignment programs can directly deal with gain and dark
# correction images, so we don't need to apply it
if self._doCorrectGain():
self.info("Correcting gain and dark '%s' -> '%s'" %
(inputMovieFn, outputMovieFn))
gain, dark = self.getGainAndDark()
self.correctGain(inputMovieFn,
outputMovieFn,
gainFn=gain,
darkFn=dark)
else:
self.info("Converting movie '%s' -> '%s'" %
(inputMovieFn, outputMovieFn))
emlib.image.ImageHandler().convertStack(
inputMovieFn, outputMovieFn)
# Just store the original name in case it is needed in _processMovie
movie._originalFileName = pwobj.String(objDoStore=False)
movie._originalFileName.set(movie.getFileName())
# Now set the new filename (either linked or converted)
movie.setFileName(os.path.join(movieFolder, newMovieName))
self.info("Processing movie: %s" % movie.getFileName())
self._processMovie(movie)
if self._doMovieFolderCleanUp():
self._cleanMovieFolder(movieFolder)
# Mark this movie as finished
open(movieDoneFn, 'w').close()
def operateStep(self):
outputSet = self.inputSet.get().create(self._getPath())
for oldEntry in self.inputSet.get():
fnSmall = oldEntry.smallMoleculeFile.get()
fnBase = os.path.splitext(os.path.split(fnSmall)[1])[0]
fnName = self._getExtraPath(fnBase+".txt")
cid = None
if not os.path.exists(fnName):
if fnSmall.endswith('.smi'):
fhSmile = open(fnSmall)
smile = fhSmile.readlines()[0].split()[0].strip() # Only first line
fhSmile.close()
url = "https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/smiles/%s/cids/TXT"%smile
print(url)
pubChemName = ""
try:
with contextlib.closing(urllib.request.urlopen(url)) as fp:
mybytes = fp.read()
cid = mybytes.decode("utf8").split()[0]
fp.close()
if cid!="0":
url = "https://pubchem.ncbi.nlm.nih.gov/rest/pug_view/data/compound/%s/XML/?response_type=save&response_basename=compound_CID_%s"%(cid,cid)
print(url)
fnXml = self._getTmpPath("compound.xml")
urllib.request.urlretrieve(url, fnXml)
if os.path.exists(fnXml):
tree = ET.parse(fnXml)
pubChemName = ""
for child in tree.getroot().iter():
if "RecordTitle" in child.tag:
pubChemName = child.text
print(pubChemName)
fh = open(fnName,'w')
fh.write(pubChemName+" ;; %s"%cid)
fh.close()
break
except Exception as e:
print(e)
print(" Could not be retrieved")
else:
fh = open(fnName)
tokens = fh.readline().split(';;')
pubChemName = tokens[0].strip()
cid = tokens[1].strip()
fh.close()
newEntry = self.inputSet.get().ITEM_TYPE()
newEntry.copy(oldEntry)
newEntry.pubChemName = pwobj.String(pubChemName)
if cid is not None and cid!="0":
url = "https://pubchem.ncbi.nlm.nih.gov/compound/%s"%cid
else:
url = ""
newEntry.pubChemURL = pwobj.String(url)
outputSet.append(newEntry)
if len(outputSet)>0:
self._defineOutputs(output=outputSet)
self._defineSourceRelation(self.inputSet, outputSet)
def __init__(self, **args):
pwprot.Protocol.__init__(self, **args)
self.name = pwobj.String(args.get('name', None))
