Python XSDataFile.setPath方法代码示例

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def doSuccessSaxsMac(self, _edPlugin=None):
        EDVerbose.DEBUG("EDPluginBioSaxsAveragev1_0.doSuccessSaxsMac")
        self.retrieveSuccessMessages(_edPlugin, "EDPluginBioSaxsAveragev1_0.doSuccessSaxsMac")
        strEdnaLogFile = os.path.join(_edPlugin.getWorkingDirectory(), _edPlugin.getScriptLogFileName())
        EDVerbose.DEBUG("ExecPlugin log file is in: %s" % strEdnaLogFile)
        if os.path.isfile(strEdnaLogFile):
            shutil.copy(strEdnaLogFile, self.strLogFile)
            xsLogFile = XSDataFile()
            xsLogFile.setPath(XSDataString(self.strLogFile))
            self.xsdResult.setLogFile(xsLogFile)

        xsdiMetadata = XSDataInputBioSaxsMetadatav1_0()
        xsdiMetadata.setInputImage(self.dataInput.getAveragedImage())
        xsdiMetadata.setOutputImage(self.dataInput.getAveragedImage())
        xsdiMetadata.setConcentration(self.xsdMetadata.concentration)
        xsdiMetadata.setComments(self.xsdMetadata.comments)
        xsdiMetadata.setCode(self.xsdMetadata.code)
        xsdiMetadata.setDetector(self.xsdMetadata.getDetector())
        xsdiMetadata.setDetectorDistance(self.xsdMetadata.detectorDistance)
        xsdiMetadata.setPixelSize_1(self.xsdMetadata.pixelSize_1)
        xsdiMetadata.setPixelSize_2(self.xsdMetadata.pixelSize_2)
        xsdiMetadata.setBeamCenter_1(self.xsdMetadata.beamCenter_1)
        xsdiMetadata.setBeamCenter_2(self.xsdMetadata.beamCenter_2)
        xsdiMetadata.setWavelength(self.xsdMetadata.wavelength)
        xsdiMetadata.setMachineCurrent(self.xsdMetadata.machineCurrent)
        xsdiMetadata.setMaskFile(self.xsdMetadata.maskFile)
        xsdiMetadata.setNormalizationFactor(self.xsdMetadata.normalizationFactor)
        self.__edPluginSaxsSetMetadata.setDataInput(xsdiMetadata)
        self.__edPluginSaxsSetMetadata.connectSUCCESS(self.doSuccessSetMetadata)
        self.__edPluginSaxsSetMetadata.connectFAILURE(self.doFailureSetMetadata)
        self.__edPluginSaxsSetMetadata.executeSynchronous()

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def characteriseWithXmlInput(self, data_collection_id, sampleCharacteriseIndex, beamsize):
        if data_collection_id is not None:
          self.ednaInput.setDataCollectionId(XSDataInteger(data_collection_id))
        else:
          self.ednaInput.setDataCollectionId(None)
          logging.getLogger().warning("The data collection ID is not known for this characterisation. Therefore the EDNA results cannot be put into the database")

        # build data set
        imageSuffix = self.beamlinePars["BCM_PARS"].getProperty("FileSuffix")
        dataSetObj = XSDataMXCuBEDataSet()
        self.ednaInput.setDataSet([])
        methodDCNo = len(self.current_method[1])
        for methodIndex in range(methodDCNo):
          number_of_images = self.current_method[1][methodIndex]['number_of_images']
          imageNameIdx = self.current_method[0]
          listIndex = sampleCharacteriseIndex * methodDCNo + methodIndex
          for imageno in range(int(number_of_images)):
              imageFileObj = XSDataFile()
              pathStrObj = XSDataString()
              pathStrObj.setValue(('%s/%s_%d_%04d.%s' % (self.collectSeqList[listIndex]['fileinfo']['directory'],\
                                                         self.collectSeqList[listIndex]['fileinfo']['prefix'],\
                                                         int(self.collectSeqList[listIndex]['fileinfo']['run_number']),\
                                                         imageno+1,imageSuffix)))
              imageFileObj.setPath(pathStrObj)
              dataSetObj.addImageFile(imageFileObj)
        self.ednaInput.addDataSet(dataSetObj)

        if TEST:
          self.ednaInput.getDataSet()[0].getImageFile()[0].getPath().setValue("/opt/pxsoft/DNA/TestCase/ref-testscale_1_001.img")
          self.ednaInput.getDataSet()[0].getImageFile()[1].getPath().setValue("/opt/pxsoft/DNA/TestCase/ref-testscale_1_002.img")
        path = self.process_dir
        suffix = '_%s.xml' % (self.ednaInput.getDataCollectionId().getValue() or id(self.ednaInput))
        ednaResultsFile = os.path.join(path, 'EDNAOutput%s' % suffix)
        ednaInputXMLFile = os.path.join(path, 'EDNAInput%s' % suffix)
        if not os.path.isdir(path):
            os.makedirs(path)

        beamObj = self.ednaInput.getExperimentalCondition().getBeam()
        beamObj.setSize(XSDataSize(x=XSDataLength(float(beamsize[0])),y=XSDataLength(float(beamsize[1]))))
        """ create an edna input file using the ednainput model """
        ednaInputXML = self.ednaInput.exportToFile(ednaInputXMLFile)

        logging.getLogger().info("Starting Edna using xml file, %s" % ednaInputXMLFile)

        # use an intermediate script to run edna with its command line options
        edna_args = "%s  %s %s" % (ednaInputXMLFile,ednaResultsFile,path)
        edna_cmd=self.StartEdnaCommand+" "+edna_args
        if self.ednaPollTimer is None:
            self.ednaPollTimer = qt.QTimer()
            qt.QObject.connect(self.ednaPollTimer,qt.SIGNAL("timeout()"), self.pollEDNA)

        logging.getLogger().debug(edna_cmd)
        EDNA_PROCESSES.append(EnhancedPopen.Popen(edna_cmd,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,shell=True,universal_newlines=True))
        self.EDNAResultsFiles[id(EDNA_PROCESSES[-1])]=ednaResultsFile
        # save image prefix,etc. for next step
        # only take first image, since we just want to have image prefix, run number, etc. :
        # it is the same within the whole collectSeqList (hopefully)
        imagePrefix = self.collectSeqList[0]['fileinfo']['prefix'][4:] #remove ref-
        self.imagePathProperties[id(EDNA_PROCESSES[-1])]={"imagePrefix":imagePrefix, "imageDir": self.collectSeqList[0]['fileinfo']['directory'], "lRunN": int(self.collectSeqList[0]['fileinfo']['run_number'])}
        self.ednaPollTimer.start(100)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
def fileName2xml(filename):
    """Here we create the XML string to be passed to the EDNA plugin from the input filename
    This can / should be modified by the final user
    
    @param filename: full path of the input file
    @type filename: python string representing the path
    @rtype: XML string
    @return: python string  
    """
    if filename.endswith(".jpg"):
        xm = None
    else:
        upperDir = os.path.dirname(os.path.dirname(filename))
        if not os.path.isdir(os.path.join(upperDir, "Thumbnail")):
               os.makedirs(os.path.join(upperDir, "Thumbnail"), int("775", 8))
        destinationPath = os.path.join(upperDir, "Thumbnail")
        xsd = XSDataInputExecThumbnail()
        xsdFile = XSDataFile()
        xsdFile.setPath(XSDataString(filename))
        xsd.setInputImagePath(xsdFile)
        xsdPath = XSDataFile()
        xsdPath.setPath(XSDataString(destinationPath))
        xsd.setOutputPath(xsdPath)
        xsd.setLevelsColorize(XSDataBoolean(True))
        xsd.setLevelsNormalize(XSDataBoolean(True))
        xsd.setLevelsGamma(XSDataFloat(gamma))
        xml = xsd.marshal()
    return xml

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def postProcess(self, _edObject=None):
        """
        postProcess of the plugin EDPluginSPDCorrectv10.py:
        - convert to HDF if needed (to be implemented)
        - move images (if needed)
        - set result XML   
        """
        EDPluginExecProcess.postProcess(self)
        self.DEBUG("EDPluginSPDCorrectv10.postProcess")
        EDUtilsPath.createFolder(self.dictGeometry["OutputDir"])

        if self.getClassName() == "EDPluginSPDCorrectv10":

            strInputImagePathNoSfx = os.path.splitext(os.path.basename(self.pathToInputFile))[0]
            destFileBaseName = strInputImagePathNoSfx + self.dictGeometry["OutputFileType"]
            strOutputFilePath = os.path.join(self.dictGeometry["OutputDir"], destFileBaseName)
            if not self._bFireAndForget:
                if "corrected" in self.dictRes:
                    strTempFilePath = self.dictRes["corrected"]
                else:
                    strTempFilePath = os.path.join(self.getWorkingDirectory(), destFileBaseName)
                if self.dictGeometry["OutputFileType"].lower() in [".hdf5", ".nexus", ".h5", ".nx"]:
                    self.WARNING("HDF5/Nexus output is not yet implemented in the SPD plugin.")
                if os.path.exists(strOutputFilePath):
                    self.WARNING("Destination file exists, I will leave result file in %s." % strTempFilePath)
                    strOutputFilePath = strTempFilePath
                else:
                    shutil.move(strTempFilePath, strOutputFilePath)
            #        # Create the output data
            xsDataFile = XSDataFile()
            xsDataFile.setPath(XSDataString(strOutputFilePath))

            xsDataResultSPD = XSDataResultSPD()
            xsDataResultSPD.setCorrectedFile(xsDataFile)
            self.setDataOutput(xsDataResultSPD)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def doSuccessExecSPDCake(self, _edPlugin=None):
        self.synchronizeOn()
        self.DEBUG("EDPluginControlID11v1_0.doSuccessExecSPDCake")
        self.retrieveSuccessMessages(_edPlugin, "EDPluginControlID11v1_0.doSuccessExecSPDCake")

        xsdOut = _edPlugin.getDataOutput()

        xsdAzimFile = xsdOut.getCakedFile()
        xsdIn = XSDataInput1DPowderEDF()
        xsdIn.setEdfFile(xsdAzimFile)

        strInputFile = os.path.basename(_edPlugin.getDataInput().getInputFile().getPath().getValue())
        xsdFile = XSDataFile()
        xsdFile.setPath(XSDataString(
               os.path.join(self.__dictID11["output_dir"], os.path.splitext(strInputFile)[0] + "." + self.__dictID11["output_extn"])
                                     ))
        xsdIn.setOutputFile(xsdFile)

        xsdIn.setEdfFile(xsdOut.getCakedFile())

        xsdIn.setOutputFormat(XSDataString(self.__dictID11["output_extn"]))
        xsdIn.setNumberOfBins(XSDataInteger(int(self.__dictID11["RADIAL BINS"])))

        # EDF Launch
        edPluginEDF = self.loadPlugin(self.__strControlledPluginEDF)
        edPluginEDF.setDataInput(xsdIn)
        edPluginEDF.connectSUCCESS(self.doSuccessExec1DPowderEDF)
        edPluginEDF.connectFAILURE(self.doFailureExec1DPowderEDF)
        edPluginEDF.execute()
        self.synchronizeOff()

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def doSuccessExecSaxsMac(self, _edPlugin=None):
        self.DEBUG("EDPluginBioSaxsNormalizev1_0.doSuccessExecSaxsMac")
        self.retrieveSuccessMessages(_edPlugin, "EDPluginBioSaxsNormalizev1_0.doSuccessExecSaxsMac")
        strEdnaLogFile = os.path.join(
            self.__edPluginExecSaxsMac.getWorkingDirectory(), self.__edPluginExecSaxsMac.getScriptLogFileName()
        )
        self.DEBUG("ExecPlugin log file is in: %s" % strEdnaLogFile)
        if os.path.isfile(self.strNormalizedImage) and self.isVerboseDebug():
            shutil.copy(self.strNormalizedImage, self.strNormalizedImage + ".bak")
        if os.path.isfile(strEdnaLogFile):
            shutil.copy(strEdnaLogFile, self.strLogFile)
            xsLogFile = XSDataFile()
            xsLogFile.setPath(XSDataString(self.strLogFile))
            self.xsdResult.setLogFile(xsLogFile)

        xsdiMetadata = XSDataInputBioSaxsMetadatav1_0()
        xsdiMetadata.setInputImage(self.xsdInput.normalizedImage)
        xsdiMetadata.setOutputImage(self.xsdInput.normalizedImage)
        xsdiMetadata.setBeamStopDiode(self.xsdInput.experimentSetup.beamStopDiode)
        xsdiMetadata.setNormalizationFactor(self.xsdInput.experimentSetup.normalizationFactor)
        xsdiMetadata.setDetector(self.xsdInput.experimentSetup.getDetector())
        xsdiMetadata.setMachineCurrent(self.xsdInput.experimentSetup.machineCurrent)
        xsdiMetadata.setMaskFile(self.xsdInput.experimentSetup.maskFile)
        xsdiMetadata.setDetectorDistance(self.xsdInput.experimentSetup.detectorDistance)
        xsdiMetadata.setWavelength(self.xsdInput.experimentSetup.wavelength)
        xsdiMetadata.setPixelSize_1(self.xsdInput.experimentSetup.pixelSize_1)
        xsdiMetadata.setPixelSize_2(self.xsdInput.experimentSetup.pixelSize_2)
        xsdiMetadata.setBeamCenter_1(self.xsdInput.experimentSetup.beamCenter_1)
        xsdiMetadata.setBeamCenter_2(self.xsdInput.experimentSetup.beamCenter_2)

        xsdiMetadata.setConcentration(self.xsdInput.sample.concentration)
        xsdiMetadata.setComments(self.xsdInput.sample.comments)
        xsdiMetadata.setCode(self.xsdInput.sample.code)

        self.__edPluginExecMetadata.setDataInput(xsdiMetadata)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def create_autoproc_input(self, event, params):
        """
        Descript. :
        """
        WAIT_XDS_TIMEOUT = 20
        WAIT_XDS_RESOLUTION = 1

        file_name_timestamp = time.strftime("%Y%m%d_%H%M%S")
        
        autoproc_path = params.get("xds_dir")
        autoproc_xds_filename = os.path.join(autoproc_path, "XDS.INP")
        autoproc_input_filename = os.path.join(autoproc_path, 
                                                "edna-autoproc-input-%s" % \
                                                file_name_timestamp)
        autoproc_output_file_name = os.path.join(autoproc_path, 
                                                 "edna-autoproc-results-%s" % \
                                                 file_name_timestamp)

        autoproc_input = XSDataAutoprocInput() 
        autoproc_xds_file = XSDataFile()
        autoproc_xds_file.setPath(XSDataString(autoproc_xds_filename))
        autoproc_input.setInput_file(autoproc_xds_file)

        autoproc_output_file = XSDataFile()
        autoproc_output_file.setPath(XSDataString(autoproc_output_file_name))
        autoproc_input.setOutput_file(autoproc_output_file)

        autoproc_input.setData_collection_id(XSDataInteger(params.get("collection_id")))
        residues_num = float(params.get("residues", 0))
        if residues_num != 0:
            autoproc_input.setNres(XSDataDouble(residues_num)) 
        space_group = params.get("sample_reference").get("spacegroup", "")
        if len(space_group) > 0:
            autoproc_input.setSpacegroup(XSDataString(space_group)) 
        unit_cell = params.get("sample_reference").get("cell", "")
        if len(unit_cell) > 0:
            autoproc_input.setUnit_cell(XSDataString(unit_cell))

        autoproc_input.setCc_half_cutoff(XSDataDouble(18.0))
       
        #Maybe we have to check if directory is there. Maybe create dir with mxcube
        xds_appeared = False
        wait_xds_start = time.time()
        logging.debug('EMBLAutoprocessing: Waiting for XDS.INP file: %s' % autoproc_xds_filename)
        while not xds_appeared and time.time() - wait_xds_start < WAIT_XDS_TIMEOUT:
            if os.path.exists(autoproc_xds_filename) and os.stat(autoproc_xds_filename).st_size > 0:
                xds_appeared = True
                logging.debug('EMBLAutoprocessing: XDS.INP file is there, size={0}'.\
                        format(os.stat(autoproc_xds_filename).st_size))
            else:
                os.system("ls %s> /dev/null"%(os.path.dirname(autoproc_path)))
                gevent.sleep(WAIT_XDS_RESOLUTION)
        if not xds_appeared:
            logging.error('EMBLAutoprocessing: XDS.INP file ({0}) failed to appear after {1} seconds'.\
                    format(autoproc_xds_filename, WAIT_XDS_TIMEOUT))
            return None, False
 
        autoproc_input.exportToFile(autoproc_input_filename)

        return autoproc_input_filename, True

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
 def postProcess(self, _edObject=None):
     EDPluginExec.postProcess(self)
     EDVerbose.DEBUG("EDPluginExecOutputHTMLv1_0.postProcess")
     if self.__strWorkingDir != None:
         xsDataFileHTMLFile = XSDataFile()
         xsDataFileHTMLDir = XSDataFile()
         
         if self.strBasename is None:
             strHTMLFilePath = os.path.join(self.__strWorkingDir, "edna.html")
             strHTMLDirPath = os.path.join(self.__strWorkingDir, "edna_html")
         else:
             strHTMLFilePath = os.path.join(self.strBasename, "edna.html")
             strHTMLDirPath = os.path.join(self.strBasename, "edna_html")
         
         if os.path.exists(strHTMLFilePath):
             strFileContent = EDUtilsFile.readFile(strHTMLFilePath)
             strFileContent = strFileContent.replace("table,td,th { border-style: none;", "div.edna table,td,th { border-style: none;")
             strFileContent = strFileContent.replace("td,th { border-style: solid;", "div.edna td,th { border-style: solid;")
             strFileContent = strFileContent.replace("th { background-color: gray;", "div.edna th { background-color: gray;")
             strFileContent = strFileContent.replace("<body onload=\"initTable('strategyData',false,false);\">", "<body onload=\"initTable('strategyData',false,false);\"><div class = 'edna'> ")
             strFileContent = strFileContent.replace("</body>", "</div></body>")
             EDUtilsFile.writeFile(strHTMLFilePath, strFileContent)
             xsDataFileHTMLFile.setPath(XSDataString(strHTMLFilePath))
             xsDataFileHTMLDir.setPath(XSDataString(strHTMLDirPath))
             self.setDataOutput(xsDataFileHTMLFile, "htmlFile")
             self.setDataOutput(xsDataFileHTMLDir, "htmlDir")
         else:
             EDVerbose.ERROR("EDPluginExecOutputHTMLv1_0.postProcess: file doesn't exist: " + strHTMLFilePath)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
def functionXMLin(_strFilename):
    """Here we create the XML string to be passed to the EDNA plugin from the input strFilename
    This can / should be modified by the final user
    
    @param _strFilename: full path of the input file
    @type _strFilename: python string representing the path
    @return: string  
    """
    EDVerbose.screen("Starting processing of image %s" % (_strFilename))
    # First check if the filename end with .img or .mccd:
    strXML = None
    if _strFilename.endswith(".img") or _strFilename.endswith(".mccd") or _strFilename.endswith(".cbf"):
        xsDataInputGridScreening = XSDataInputGridScreening()
        xsDataDiffractionPlan = XSDataDiffractionPlan()
        xsDataDiffractionPlan.setMaxExposureTimePerDataCollection(
            XSDataTime(EDParallelExecuteGridScreening.fMaxExposureTime)
        )
        xsDataInputGridScreening.setDiffractionPlan(xsDataDiffractionPlan)
        xsDataFile = XSDataFile()
        xsDataFile.setPath(XSDataString(_strFilename))
        xsDataInputGridScreening.setImageFile(xsDataFile)
        if EDParallelExecuteGridScreening.bOnlyImageQualityIndicators:
            xsDataInputGridScreening.setDoOnlyImageQualityIndicators(XSDataBoolean(True))
        if EDParallelExecuteGridScreening.bStoreInISPyB:
            xsDataInputGridScreening.setStoreImageQualityIndicatorsInISPyB(XSDataBoolean(True))
        if EDParallelExecuteGridScreening.bDoOnlyIntegrationWithXMLOutput:
            xsDataInputGridScreening.setDoOnlyIntegrationWithXMLOutput(XSDataBoolean(True))
        strXML = xsDataInputGridScreening.marshal()
    else:
        EDVerbose.screen("File name not ending with .img or .mccd - ignored : %s" % _strFilename)
    return strXML

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
 def createInputCharacterisationFromImageHeaders(self, _edPlugin):
     self.DEBUG("EDPluginControlInterfacev1_3.createInputCharacterisationFromImageHeaders")
     xsDataInputSubWedgeAssemble = XSDataInputSubWedgeAssemble()
     for xsDataStringImagePath in self.listImagePaths:
         xsDataFile = XSDataFile()
         xsDataFile.setPath(xsDataStringImagePath)
         xsDataInputSubWedgeAssemble.addFile(xsDataFile)
     _edPlugin.setDataInput(xsDataInputSubWedgeAssemble)
     _edPlugin.executeSynchronous()

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
 def postProcess(self, _edObject=None):
     EDPluginExecProcessScript.postProcess(self)
     self.DEBUG("EDPluginExecSiftDescriptorv1_0.postProcess")
     # Create some output data
     xsDataResult = XSDataResultSiftDescriptor()
     if os.path.isfile(self.strKeys):
         xsdFile = XSDataFile()
         xsdFile.setPath(XSDataString(self.strKeys))
         xsDataResult.setDescriptorFile(xsdFile)
     self.setDataOutput(xsDataResult)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
 def postProcess(self, _edObject=None):
     EDPluginExecProcessScript.postProcess(self)
     EDVerbose.DEBUG("*** EDPluginFIT2DCakev1_0.postProcess")
     # Create the output data
     xsDataResultFIT2DCake = XSDataResultFIT2DCake()
     if (self.m_strOutputFilePath is not None):
         xsDataFile = XSDataFile()
         xsDataFile.setPath(XSDataString(self.m_strOutputFilePath))
         xsDataResultFIT2DCake.setResultFile(xsDataFile)
     self.setDataOutput(xsDataResultFIT2DCake)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
 def postProcess(self, _edObject=None):
     EDPluginExecProcessScript.postProcess(self)
     EDVerbose.DEBUG("EDPluginExecVideov10.postProcess")
     # Create some output data
     xsDataResult = XSDataResultExecVideo()
     xsDataFile = XSDataFile()
     xsDataFile.setPath(XSDataString(self.videoFile))
     xsDataResult.setVideoPath(xsDataFile)
     xsDataResult.setVideoPath(xsDataFile)
     xsDataResult.setVideoCodec(XSDataString(self.codec))
     self.setDataOutput(xsDataResult)

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
 def compressRaw(self):
     xsdin = XSDataInputExecCommandLine()
     xsdin.setFireAndForget(XSDataBoolean(1))
     xsdin.setInputFileName(self.getDataInput().getInputRaw())
     xsdin.setCommandLineOptions(XSDataString("-9"))
     xsdf = XSDataFile()
     xsdf.setPath(XSDataString("/bin/bzip2"))
     xsdin.setCommandLineProgram(xsdf)
     self.__edPluginExecBzip2.setDataInput(xsdin)
     self.__edPluginExecBzip2.connectSUCCESS(self.doSuccessExecBzip2)
     self.__edPluginExecBzip2.connectFAILURE(self.doFailureExecBzip2)
     self.__edPluginExecBzip2.executeSynchronous()

# 需要导入模块: from XSDataCommon import XSDataFile [as 别名]
# 或者: from XSDataCommon.XSDataFile import setPath [as 别名]
    def postProcess(self, _edObject=None):
        EDPluginExecProcessScript.postProcess(self)
        EDVerbose.DEBUG("EDPluginExecGnomv0_1.postProcess")
        # Create some output data
        xsDataResult = self.parseGnomOutputFile()

        xsDataFile = XSDataFile()
        xsDataFile.setPath(XSDataString(os.path.join(self.getWorkingDirectory(), "gnom.out")))

        xsDataResult.setOutput(xsDataFile)

        self.setDataOutput(xsDataResult)