def testCifCheck(self):
""" """
logger.info("\nStarting")
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
cifPath = os.path.join(self.__testFilePath, self.__testFileCif)
dp.imp(cifPath)
dp.op("check-cif")
dp.exp("check-cif-diags.txt")
dp.expLog("check-cif.log")
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
def testCifToPdb(self):
""" """
logger.info("\nStarting")
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
cifPath = os.path.join(self.__testFilePath, self.__testFileCif)
dp.imp(cifPath)
dp.op("cif2pdb")
dp.exp("myTest1.pdb.gz")
dp.expLog("myLog1.log.gz")
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
def convert_em_volume(self, in_em_volume, out_binary_volume, working_dir):
logging.info("Converting EM maps to binary cif")
logging.debug(working_dir)
rdb = RcsbDpUtility(tmpPath=working_dir,
siteId=self.__site_id,
verbose=True)
rdb.imp(in_em_volume)
rdb.op("em-density-bcif")
rdb.exp(out_binary_volume)
rdb.cleanup()
if out_binary_volume:
if os.path.exists(out_binary_volume):
return True
return False
def testAnnotValidateGeometryCheck(self):
""" Test of updating geometrical validation diagnostics -
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
of = "annot-validate-geometry-check.cif"
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
inpPath = os.path.join(self.__testFilePath, self.__testFileAnnotSite)
dp.imp(inpPath)
dp.op("annot-validate-geometry")
dp.expLog("annot-validate-geometry-check-pdbx.log")
dp.exp(of)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testCifCheck(self):
"""
"""
logger.info("\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
cifPath = os.path.join(self.__testFilePath, self.__testFileCif)
dp.imp(cifPath)
dp.op("check-cif")
dp.exp("check-cif-diags.txt")
dp.expLog("check-cif.log")
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testMapFix(self):
""" Test mapfix utility
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
#
inpPath = os.path.join(self.__testFilePath, self.__testMapNormal)
of = self.__testMapNormal + "-fix.map"
dp.imp(inpPath)
dp.op("mapfix-big")
dp.expLog("mapfix-big.log")
dp.exp(of)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testAnnotFormatCheck(self):
""" Test format sanity check for pdbx
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
of = "annot-format-check.txt"
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
#
inpPath = os.path.join(self.__testFilePath, self.__testFileAnnotSite)
dp.imp(inpPath)
dp.op("annot-format-check-pdbx")
dp.expLog("format-check-pdbx.log")
dp.exp(of)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testValidateGeometryCheck(self):
"""Test format sanity check for pdbx"""
logger.info("\nStarting")
try:
of = "validate-geometry-check.cif"
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
inpPath = os.path.join(self.__testFilePath,
self.__testFileAnnotSite)
dp.imp(inpPath)
dp.op("validate-geometry")
dp.expLog("validate-geometry-check-pdbx.log")
dp.exp(of)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
def testCif2pdbx_public(self):
"""Test cif to pdbx conversion (good cif)"""
logger.debug("\nStarting")
cifout = os.path.join(self.__tmpPath, self.__testFileAnnotSiteAlt)
#
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
cifin = os.path.join(self.__testFilePath, self.__testFileAnnotSiteAlt)
dp.imp(cifin)
dp.exp(cifout)
dp.expLog(os.path.join(self.__tmpPath, "cif2pdbx-public.log"))
ret = dp.op("cif2pdbx-public")
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(cifin)
self.assertTrue(cifout)
def test_AnnotValidateGeometryCheck(self):
"""Test of updating geometrical validation diagnostics -"""
logger.debug("\nStarting")
of = os.path.join(self.__tmpPath, "annot-validate-geometry-check.cif")
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
inp_path = os.path.join(self.__testFilePath, self.__testFileAnnotSite)
dp.imp(inp_path)
ret = dp.op("annot-validate-geometry")
dp.expLog(
os.path.join(self.__tmpPath,
"annot-validate-geometry-check-pdbx.log"))
dp.exp(of)
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(of))
def testCif2pdbx_public(self):
""" Test cif to pdbx conversion (good cif)
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
cifout = os.path.join(self.__tmpPath, self.__testFileAnnotSiteAlt)
#
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
cifin = os.path.join(self.__testFilePath, self.__testFileAnnotSiteAlt)
dp.imp(cifin)
dp.exp(cifout)
dp.expLog(os.path.join(self.__tmpPath, "cif2pdbx-public.log"))
ret = dp.op("cif2pdbx-public")
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(cifin)
self.assertTrue(cifout)
def test_AnnotValidateGeometryCheck(self):
""" Test of updating geometrical validation diagnostics -
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
of = os.path.join(self.__tmpPath, "annot-validate-geometry-check.cif")
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
inp_path = os.path.join(self.__testFilePath, self.__testFileAnnotSite)
dp.imp(inp_path)
ret = dp.op("annot-validate-geometry")
dp.expLog(
os.path.join(self.__tmpPath,
"annot-validate-geometry-check-pdbx.log"))
dp.exp(of)
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(of))
def testAnnotRcsb2PdbxRemote(self):
"""RCSB CIF -> PDBx conversion (Using the smaller application in the annotation package)
Converting to RCSB to PDB id in _entry.id and related items.
"""
logger.debug("\nStarting")
of = os.path.join(
self.__tmpPath,
"annot-rcsb2pdbx-withpdbid-" + self.__testFileAnnotRcsb)
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
inpPath = os.path.join(self.__testFilePath, self.__testFileAnnotRcsb)
dp.imp(inpPath)
# dp.setRunRemote()
ret = dp.op("annot-rcsb2pdbx-withpdbid")
dp.expLog(os.path.join(self.__tmpPath, "annot-rcsb2pdbx.log"))
dp.exp(of)
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(of))
def testXmlHeaderCheck(self):
""" Test xmllint
"""
logger.info("\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
#
# dp.setDebugMode()
inpPath = os.path.join(self.__testFilePath, self.__testXMLHeader)
# of = self.__testXMLHeader + ".check"
dp.imp(inpPath)
dp.op("xml-header-check")
dp.expLog("xml-header-check.log")
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testAnnotMtz2PdbxGood(self):
""" Test mtz to pdbx conversion (good mtz)
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
diagfn = os.path.join(self.__tmpPath, "sf-convert-diags.cif")
ciffn = os.path.join(self.__tmpPath, "sf-convert-datafile.cif")
dmpfn = os.path.join(self.__tmpPath, "sf-convert-mtzdmp.log")
#
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
mtzPath = os.path.join(self.__testFilePath, self.__testFileMtzGood)
dp.imp(mtzPath)
dp.setTimeout(15)
ret = dp.op("annot-sf-convert")
dp.expLog(os.path.join(self.__tmpPath, "sf-convert.log"))
dp.expList(dstPathList=[ciffn, diagfn, dmpfn])
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(ciffn)
self.assertTrue(diagfn)
self.assertTrue(dmpfn)
def test_AnnotMergeRemote(self):
""" Test of updating geometrical validation diagnostics -
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
for pdbId in self.__testValidateXrayIdList:
self.__tmpPath = tempfile.mkdtemp(
dir=self.__siteWebAppsSessionsPath)
testFileValidateXyz = pdbId + ".cif"
xyzPath = os.path.abspath(
os.path.join(self.__testFilePath, testFileValidateXyz))
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
of = os.path.join(self.__tmpPath, "annot-merge-xyz-remote.cif")
dp.imp(xyzPath)
dp.addInput(name="new_coordinate_file_path", value=xyzPath)
dp.addInput(name="new_coordinate_format", value='cif')
# dp.setRunRemote()
ret = dp.op("annot-merge-xyz")
dp.expLog(
os.path.join(self.__tmpPath, "annot-merge-xyz-remote.log"))
dp.exp(of)
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(of))
def testAnnotSiteRemote(self):
""" Calculate site environment
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
of = os.path.join(self.__tmpPath,
"annot-site-" + self.__testFileAnnotSite)
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
inpPath = os.path.join(self.__testFilePath, self.__testFileAnnotSite)
dp.imp(inpPath)
dp.addInput(name="block_id", value=self.__testIdAnnotSite)
# dp.setRunRemote()
ret = dp.op("annot-site")
dp.expLog(os.path.join(self.__tmpPath, "annot-site.log"))
dp.exp(of)
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(of))
def testMapFixRemote(self):
""" Test mapfix utility
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
#
inpPath = os.path.join(self.__testFilePath, self.__testMapNormal)
of = os.path.join(self.__tmpPath, self.__testMapNormal + "-fix.map")
dp.imp(inpPath)
pixelSize = 2.54
#dp.addInput(name="pixel-spacing-x", value=pixelSize)
#dp.addInput(name="pixel-spacing-y", value=pixelSize)
#dp.addInput(name="pixel-spacing-z", value=pixelSize)
dp.addInput(name="input_map_file_path", value=inpPath)
dp.addInput(name="output_map_file_path", value=of)
dp.addInput(name="label", value='test')
dp.addInput(name="voxel", value='{0} {0} {0}'.format(pixelSize))
# dp.setRunRemote()
ret = dp.op("deposit-update-map-header-in-place")
dp.expLog(os.path.join(self.__tmpPath, "mapfix-big.log"))
dp.exp(of)
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(of))
def testEm2EmSpider(self):
"""Test mapfix utility"""
logger.info("\nStarting")
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
#
inpPath = os.path.join(self.__testFilePath, self.__testMapSpider)
of = self.__testMapSpider + "-spider-cnv.map"
dp.imp(inpPath)
pixelSize = 2.54
dp.addInput(name="pixel-spacing-x", value=pixelSize)
dp.addInput(name="pixel-spacing-y", value=pixelSize)
dp.addInput(name="pixel-spacing-z", value=pixelSize)
dp.op("em2em-spider")
dp.expLog("em2em-spider.log")
dp.exp(of)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
def testPisaAnalysisPdb(self):
"""
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
pdbPath = os.path.join(self.__testFilePath, self.__testFilePdbPisa)
dp.imp(pdbPath)
dp.addInput(name="pisa_session_name", value="session_3re3_pdb")
dp.op("pisa-analysis")
dp.expLog("pisa-anal-pdb.log.gz")
dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def read_mtz_sf(self, pathin):
"""Reads MTZ structure factor file
Return True on success, otherwise False
"""
logger.debug("Starting mtz read %s" % pathin)
suffix = '-dir'
prefix = 'rcsb-'
if self.__tmppath is not None and os.path.isdir(self.__tmppath):
workpath = tempfile.mkdtemp(suffix, prefix, self.__tmppath)
else:
workpath = tempfile.mkdtemp(suffix, prefix)
diagfn = os.path.join(workpath, "sf-convert-diags.cif")
ciffn = os.path.join(workpath, "sf-convert-datafile.cif")
dmpfn = os.path.join(workpath, "sf-convert-mtzdmp.log")
logfn = os.path.join(workpath, "sf-convert.log")
dp = RcsbDpUtility(siteId=self.__siteid, tmpPath=self.__tmppath)
dp.imp(pathin)
dp.op('annot-sf-convert')
dp.expLog(logfn)
dp.expList(dstPathList=[ciffn, diagfn, dmpfn])
if os.path.exists(ciffn):
ret = self.read_mmcif_sf(ciffn)
else:
ret = False
if self.__cleanup:
dp.cleanup()
shutil.rmtree(workpath, ignore_errors=True)
return ret
def testCifCheckExt(self):
""" """
logger.info("\nStarting")
try:
for name in ["deposit", "archive_current", "archive_next"]:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
cifPath = os.path.join(self.__testFilePath, self.__testFileCif)
dp.imp(cifPath)
dp.addInput(name="dictionary", value=name)
dp.op("check-cif-ext")
dp.exp("check-cif-diags-%s.txt" % name)
dp.expLog("check-cif-%s.log" % name)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
def __generateLoadDb(self, tmpPath, filePath, sql_file, logFile):
try:
dp = RcsbDpUtility(tmpPath=tmpPath,
siteId=self.__siteId,
verbose=self.__verbose,
log=self.__lfh)
dp.imp(filePath)
dp.addInput(name="mapping_file", value=self.__mapping, type="file")
# This code handles model files - first block
dp.addInput(name="first_block", value=True)
dp.op("db-loader")
dp.expLog(logFile)
dp.exp(sql_file)
dp.cleanup()
return
except: # noqa: E722 pylint: disable=bare-except
self.__lfh.write(
"DbLoadingApi::__generateLoadDb(): failing, with exception.\n")
traceback.print_exc(file=self.__lfh)
def testAnnotPrdSearch(self):
"""Test case for PRD Search --"""
logger.info("\nStarting")
try:
ofn = "prd-search-result.cif"
firstModelPath = os.path.abspath("firstmodel.cif")
logFilePath = os.path.abspath("prd-search-log.log")
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
inpPath = os.path.join(self.__testFilePath,
self.__testFilePrdSearch)
dp.imp(inpPath)
dp.addInput(name="firstmodel", value=firstModelPath)
dp.addInput(name="logfile", value=logFilePath)
dp.op("prd-search")
dp.expLog("prd-search-execution.log")
dp.exp(ofn)
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
def testPisaAssemblyDownloadModelPdb(self):
"""
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
fPath = os.path.join(self.__testFilePath, self.__testFileCifPisa)
dp.imp(fPath)
dp.addInput(name="pisa_session_name", value="session_3re3_cif")
dp.op("pisa-analysis")
dp.expLog("pisa-anal-assembly-cif.log.gz")
dp.op("pisa-assembly-report-xml")
dp.exp("pisa-assembly-report-cif.xml")
dp.expLog("pisa-report-xml-cif.log.gz")
#
for assemId in ['1', '2', '3', '4', '5']:
dp.addInput(name="pisa_assembly_id", value=assemId)
oFileName = '3rer-assembly-' + assemId + '.pdb.gz'
oLogName = '3rer-assembly-' + assemId + '-pdb.log.gz'
dp.op("pisa-assembly-coordinates-pdb")
dp.exp(oFileName)
dp.expLog(oLogName)
dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testAnnotValidateXrayNeutronRemote(self):
""" Test create validation report for the test list of example PDB ids (x-ray examples)
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
self.__tmpPath = tempfile.mkdtemp(dir=self.__siteWebAppsSessionsPath)
self.__lfh.write("\nStarting x-ray neutron in {}\n".format(
self.__tmpPath))
ofpdf = os.path.join(self.__tmpPath, "test-valrpt.pdf")
ofxml = os.path.join(self.__tmpPath, "test-valdata.xml")
offullpdf = os.path.join(self.__tmpPath, "test-valrpt_full.pdf")
ofpng = os.path.join(self.__tmpPath, "test-val-slider.png")
ofsvg = os.path.join(self.__tmpPath, "test-val-slider.svg")
#
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
# dp.setDebugMode(True)
xyzPath = os.path.abspath(
os.path.join(self.__testFilePath,
self.__testValidateXrayNeutronModel))
sfPath = os.path.abspath(
os.path.join(self.__testFilePath,
self.__testValidateXrayNeutronSF))
# dp.addInput(name="request_annotation_context", value="yes")
dp.addInput(name="request_validation_mode", value="annotate")
dp.addInput(name='run_dir',
value=os.path.join(
self.__siteWebAppsSessionsPath,
"validation_%s" % random.randrange(9999999)))
# dp.addInput(name="request_validation_mode", value="server")
dp.imp(xyzPath)
dp.addInput(name="sf_file_path", value=sfPath)
# dp.setRunRemote()
ret = dp.op("annot-wwpdb-validate-all")
dp.expLog(os.path.join(self.__tmpPath, "test-annot-validate-test.log"))
dp.expList(dstPathList=[ofpdf, ofxml, offullpdf, ofpng, ofsvg])
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(ofpdf))
self.assertTrue(os.path.exists(ofxml))
self.assertTrue(os.path.exists(offullpdf))
self.assertTrue(os.path.exists(ofpng))
self.assertTrue(os.path.exists(ofsvg))
def testPisaAssemblyMergeModelCif(self):
"""
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
fPath = os.path.join(self.__testFilePath, self.__testFileCifPisa)
assignPath = os.path.join(self.__testFilePath, "3rer_assembly_assign_P1.cif")
dp.imp(fPath)
dp.addInput(name="pisa_session_name", value="session_3re3-cif")
dp.op("pisa-analysis")
dp.op("pisa-assembly-report-xml")
dp.exp("pisa-assembly-report-cif.xml")
#
cifPath = os.path.join(self.__testFilePath, self.__testFileCifPisa)
dp.imp(cifPath)
#
# assignmentFile = self.__inputParamDict['pisa_assembly_assignment_file_path']
#
dp.addInput(name="pisa_assembly_file_path", value="pisa-assembly-report-cif.xml", type="file")
dp.addInput(name="pisa_assembly_assignment_file_path", value=assignPath, type="file")
dp.op("pisa-assembly-merge-cif")
dp.exp("3rer-updated.cif.gz")
dp.expLog("3rer-updated-cif.log.gz")
# dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testAnnotValidateListNmrTestRemote(self):
""" Test create validation report for the test list of example PDB ids (NMR examples)
"""
self.__lfh.write(
"\nStarting %s %s\n" %
(self.__class__.__name__, sys._getframe().f_code.co_name))
for pdbId in self.__testValidateNmrIdList:
self.__tmpPath = tempfile.mkdtemp(
dir=self.__siteWebAppsSessionsPath)
self.__lfh.write("\nStarting {} in {}\n".format(
pdbId, self.__tmpPath))
ofpdf = os.path.join(self.__tmpPath, pdbId + "-valrpt.pdf")
ofxml = os.path.join(self.__tmpPath, pdbId + "-valdata.xml")
offullpdf = os.path.join(self.__tmpPath,
pdbId + "-valrpt_full.pdf")
ofpng = os.path.join(self.__tmpPath, pdbId + "-val-slider.png")
ofsvg = os.path.join(self.__tmpPath, pdbId + "-val-slider.svg")
#
testFileValidateXyz = pdbId + ".cif"
testFileValidateCs = pdbId + "-cs.cif"
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
xyzPath = os.path.abspath(
os.path.join(self.__testFilePath, testFileValidateXyz))
csPath = os.path.abspath(
os.path.join(self.__testFilePath, testFileValidateCs))
dp.addInput(name="request_annotation_context", value="yes")
dp.addInput(name='run_dir',
value=os.path.join(
self.__siteWebAppsSessionsPath,
"validation_%s" % random.randrange(9999999)))
# adding explicit selection of steps --
# Alternate
#dp.addInput(name="step_list", value=" coreclust,chemicalshifts,writexml,writepdf ")
dp.addInput(name='kind', value='nmr')
dp.imp(xyzPath)
dp.addInput(name="cs_file_path", value=csPath)
# dp.setRunRemote()
ret = dp.op("annot-wwpdb-validate-all")
dp.expLog(
os.path.join(self.__tmpPath,
pdbId + "-annot-validate-test.log"))
dp.expList(dstPathList=[ofpdf, ofxml, offullpdf, ofpng, ofsvg])
# dp.cleanup()
self.assertTrue(ret == 0)
self.assertTrue(os.path.exists(ofpdf))
self.assertTrue(os.path.exists(ofxml))
self.assertTrue(os.path.exists(offullpdf))
self.assertTrue(os.path.exists(ofpng))
self.assertTrue(os.path.exists(ofsvg))
def testPisaAssemblyReportXmlCif(self):
"""
"""
logger.info("\nStarting %s %s\n" % (self.__class__.__name__, sys._getframe().f_code.co_name))
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath, siteId=self.__siteId, verbose=True)
fPath = os.path.join(self.__testFilePath, self.__testFileCifPisa)
dp.imp(fPath)
dp.addInput(name="pisa_session_name", value="session_test_cif")
dp.op("pisa-analysis")
dp.expLog("pisa-anal-assembly-cif.log")
dp.op("pisa-assembly-report-xml")
dp.exp("pisa-assembly-report-cif.xml")
dp.expLog("pisa-report-xml-cif.log")
#
dp.op("pisa-interface-report-xml")
dp.exp("pisa-interface-report-cif.xml")
dp.expLog("pisa-interface-report-xml-cif.log")
dp.cleanup()
except Exception as e:
logger.exception("Failing with %s" % str(e))
self.fail()
def testFixSpecialPosition(self):
"""Test for fixing atoms on special position"""
logger.info("\nStarting")
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
#
inpPath = os.path.join(self.__testFilePath,
self.__testFileValidateXyz)
dp.imp(inpPath)
dp.op("annot-dcc-fix-special-position")
dp.expLog("special-position-fix.log")
dp.exp("special-position-output-fix.log")
# No output - none on special
self.assertEqual(["missing"], dp.getResultPathList())
f = open("special-position-output-fix.log", "r")
lines = f.read()
f.close()
self.assertIn("No atoms sit on special position", lines)
dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
# This case has atoms on special position that needs correction
try:
dp = RcsbDpUtility(tmpPath=self.__tmpPath,
siteId=self.__siteId,
verbose=True)
#
# dp.setDebugMode(True)
#
inpPath = os.path.join(self.__testFilePath,
self.__testSpecialPosition)
dp.imp(inpPath)
dp.op("annot-dcc-fix-special-position")
dp.expLog("special-position-fix2.log")
dp.exp("special-position-output-fix2.log")
print(dp.getResultPathList())
# We expect output
self.assertNotEqual(["missing"], dp.getResultPathList())
dp.expList(dstPathList=["special-position-out-fix2.cif"])
# Check output - for differences...
f = open("special-position-output-fix2.log", "r")
lines = f.read()
f.close()
self.assertIn(
"Error: Wrong occupancy of 1.00 for atom (O : id=D_HOH_1)",
lines)
dp.cleanup()
except Exception as e:
logger.exception("Failing with %s", str(e))
self.fail()
