Python EDLogging.EDLogging类代码示例

 def __init__(self, _strFileName=None):
     """"Set  up semaphore for thread safeness and dictionary for config files"""
     EDLogging.__init__(self)
     self._dictConfigurationFiles = {}
     self._dictPluginConfiguration = {}
     if _strFileName is not None:
         self.addConfigurationFile(_strFileName)

 def __init__(self):
     EDLogging.__init__(self)
     strEdnaHome = EDUtilsPath.EDNA_HOME
     # Default plugin root directory: $EDNA_HOME
     self.__listPluginRootDirectory = [ strEdnaHome ]
     self.__dictModuleLocation = None
     self.__strPathToModuleCache = None

 def __init__(self, _strPluginName):
     """
     Constructor of the class
     
     @param strPluginName: name of the plugin 
     @type strPluginName: string
     """
     EDLogging.__init__(self)
     self.__strPluginName = _strPluginName
     self.__edPlugin = None
     self.__edSlotCallBack = EDSlot()
     self.__edSlotSUCCESS = EDSlot()
     self.__edSlotFAILURE = EDSlot()
     self.__pathXSDInput = None
     self.__pathXSDOutput = None
     self.__bXmlInputSet = False
     self.__status = None
     self.__name = None
     self.__runtime = None
     self.__edPlugin = EDJob.__edFactoryPlugin.loadPlugin(self.__strPluginName)
     if self.__edPlugin is None:
         raise RuntimeError("Unable to create plugin %s" % self.__strPluginName)
     self.__jobId = "%s-%08i" % (self.__strPluginName, self.__edPlugin.getId())
     with self.__class__.__semaphore:
         self.__class__.__dictJobs[self.__jobId] = self
     if (self.__edPlugin is None):
         self.WARNING("Instantiation of plugin %s failed!!!" % _strPluginName)
     else:
         self.__status = EDJob.PLUGIN_STATE_UNITIALIZED

    def __init__(self, _strPluginName, _functXMLin, \
                  _functXMLout=None, _functXMLerr=None, \
                  _iNbThreads=None, _fDelay=1.0, _bVerbose=None, _bDebug=None):
        """
        This is the constructor of the edna plugin launcher.
        
        @param _strPluginName: the name of the ENDA plugin
        @type  _strPluginName: python string
        
        @param _functXMLin: a function taking a path in input and returning the XML string for input in the EDNA plugin. 
        @type  _functXMLin: python function
        
        @param _functXMLOut: a function to be called each time a plugin gas finished his job sucessfully, it should take two option: strXMLin an strXMLout
        @type  _functXMLOut: python function
         
        @param _functXMLErr: a function to be called each time a plugin gas finished his job and crashed, it should take ONE option: strXMLin
        @type  _functXMLErr: python function 
        
        @param _iNbThreads: The number of parallel threads to be used by EDNA, usually the number of Cores of the computer. If 0 or None, the number of cores  will be auto-detected. 
        @type  _iNbThreads: python integer
        
        @param _fDelay: The delay in seconds between two directories analysis 
        @type  _fDelay: python float
        
        @param _bVerbose:  Do you want the EDNA plugin execution to be verbose ?
        @type  _bVerbose: boolean

        @param _bDebug:  Do you want EDNA plugin execution debug output (OBS! very verbose) ?
        @type  _bDebug: boolean
        """
        EDLogging.__init__(self)
        self.__iNbThreads = EDUtilsParallel.detectNumberOfCPUs(_iNbThreads)
        EDUtilsParallel.initializeNbThread(self.__iNbThreads)
################################################################################
# #We are not using the one from EDUtilsParallel to leave it to control the number of  execPlugins.
################################################################################
        self.__semaphoreNbThreads = Semaphore(self.__iNbThreads)
        self.__strPluginName = _strPluginName
        self.__functXMLin = _functXMLin
        self.__functXMLout = _functXMLout
        self.__functXMLerr = _functXMLerr
        self.__strCurrWorkDir = os.getcwd()
        self.__strTempDir = None
        self.__listInputPaths = []
        self.__dictCurrentlyRunning = {}
        if _bVerbose is not None:
            if _bVerbose:
                self.setVerboseDebugOn()
            else:
                self.setVerboseOff()
        if _bDebug is not None:
            if _bDebug:
                self.setVerboseDebugOn()
            else:
                self.setVerboseDebugOff()
        self.__fDelay = _fDelay #default delay between two directory checks.
        self.__bQuit = False    # To check if we should quit the application
        self.__bIsFirstExecute = True
        signal.signal(signal.SIGTERM, self.handleKill)
        signal.signal(signal.SIGINT, self.handleKill)

 def __init__(self):
     EDLogging.__init__(self)
     #EDSession is a static class
     self._backend = BACKEND
     self._filename = None
     self._storage = None
     self._listKeys = []

 def __init__(self):
     EDLogging.__init__(self)
     #EDSession is a static class
     self._backend = BACKEND
     self._filename = None
     self._storage = None
     self._listKeys = []
     self._dictAttrs = {} #attr are metadata associated to an entry. The values are always cached

 def __init__(self):
     EDLogging.__init__(self)
     # Default plugin root directory: $EDNA_HOME
     self.__listPluginRootDirectory = [EDUtilsPath.EDNA_HOME]
     for oneProjectDir in EDUtilsPath._EDNA_PROJECTS.values():
         if os.path.isdir(oneProjectDir):
             self.__listPluginRootDirectory.append(os.path.abspath(oneProjectDir))
     self.__dictModuleLocation = None

 def __init__(self, _strModuleName, _strMethodVersion=None):
     EDLogging.__init__(self)
     self.DEBUG("EDModule.__init__ on %s" % _strModuleName)
     self.__name = _strModuleName
     self.__module = None
     self.__path = None
     self.__dictSubModules = {}
     self.__version = None
     self.__strMethodVersion = _strMethodVersion

 def __init__(self, _strTestName="Test"):
     EDLogging.__init__(self)
     if _strTestName is None:
         self.__strTestName = self.getClassName()
     else:
         self.__strTestName = _strTestName
     self.__listTest = []
     self.__bIsVerbose = False
     self.__bIsDebug = False
     self.__bIsAssert = False
     self.__bIsLogFile = False
     self.__bIsProfile = False

 def __init__(self, cl, name):
     EDLogging.__init__(self)
     PyTango.Device_4Impl.__init__(self, cl, name)
     self.init_device()
     if isinstance(iNbCpu, int):
         self.screen("Initializing tangoDS with max %i jobs in parallel." % iNbCpu)
         self.__semaphoreNbThreads = threading.Semaphore(iNbCpu)
     else:
         self.__semaphoreNbThreads = threading.Semaphore(EDUtilsParallel.detectNumberOfCPUs())
     self.jobQueue = Queue()
     self.processingSem = threading.Semaphore()
     self.statLock = threading.Lock()
     self.lastStatistics = "No statistics collected yet, please use the 'collectStatistics' method first"
     self.lastFailure = "No job Failed (yet)"
     self.lastSuccess = "No job succeeded (yet)"

    def __init__(self, code=None, comment=None, \
                 maskFile=None, normalization=None, imageSize=None, detector="pilatus", detectorDistance=None, pixelSize_1=None, pixelSize_2=None, beamCenter_1=None, beamCenter_2=None, wavelength=None,):
        EDLogging.__init__(self)
        self.comment = comment
        self.code = code
        self.maskFile = maskFile
        self.normalization = normalization

        self.detector = detector
        self.detectorDistance = detectorDistance
        if (detector == "pilatus") and (pixelSize_1 is None) and (pixelSize_2 is None):
            self.pixelSize_1 = 1.72e-4
            self.pixelSize_2 = 1.72e-4
        else:
            self.pixelSize_1 = pixelSize_1
            self.pixelSize_2 = pixelSize_2
        if (detector == "pilatus") and (beamCenter_1 is None) :
            self.imageSize = 4000000
        else:
            self.imageSize = imageSize
        self.beamCenter_1 = beamCenter_1
        self.beamCenter_2 = beamCenter_2
        self.wavelength = wavelength

        self.timeStamp = time.strftime("-%Y%m%d%H%M%S", time.localtime())
        self.dest1D = "1d" + self.timeStamp
        self.dest2D = "2d" + self.timeStamp
        self.destMisc = "misc" + self.timeStamp
        self.sample = XSDataBioSaxsSample()
        if code is not None:
            self.sample.code = XSDataString(code)
        if comment is not None:
            self.sample.comment = XSDataString(comment)
        self.experimentSetup = XSDataBioSaxsExperimentSetup()
        if self.detector:
            self.experimentSetup.detector = XSDataString(self.detector)
        if self.detectorDistance:
            self.experimentSetup.detectorDistance = XSDataLength(self.detectorDistance)
        if self.pixelSize_1:
            self.experimentSetup.pixelSize_1 = XSDataLength(self.pixelSize_1)
        if self.pixelSize_2:
            self.experimentSetup.pixelSize_2 = XSDataLength(self.pixelSize_2)
        if self.beamCenter_1:
            self.experimentSetup.beamCenter_1 = XSDataDouble(self.beamCenter_1)
        if self.beamCenter_2:
            self.experimentSetup.beamCenter_2 = XSDataDouble(self.beamCenter_2)
        if self.wavelength:
            self.experimentSetup.wavelength = XSDataWavelength(self.wavelength)

    def __init__(self, strPluginName, iNbCpu=None):
        EDLogging.__init__(self)
        self.pluginName = strPluginName
        self.startTime = time.time()
        try:
            self.iNbCpu = int(iNbCpu)
        except:
            self.iNbCpu = EDUtilsParallel.detectNumberOfCPUs()

        self.screen("Initializing Reprocess with max %i jobs in parallel." % self.iNbCpu)
        self.__semaphoreNbThreads = Semaphore(self.iNbCpu)
        EDUtilsParallel.initializeNbThread(self.iNbCpu)
        self.jobQueue = Queue()
        self.processingSem = Semaphore()
        self.statLock = Semaphore()
        self.lastStatistics = "No statistics collected yet, please use the 'collectStatistics' method first"
        self.lastFailure = "No job Failed (yet)"
        self.lastSuccess = "No job succeeded (yet)"

 def __init__(self):
     EDLogging.__init__(self)
     Thread.__init__(self)
     self.__edSlotPreProcess = EDSlot()
     self.__edSlotProcess = EDSlot()
     self.__edSlotPostProcess = EDSlot()
     self.__edSlotSUCCESS = EDSlot()
     self.__edSlotFAILURE = EDSlot()
     self.__edSlotFinallyProcess = EDSlot()
     self.__bIsFailure = False
     self.__bIsTimeOut = False
     self.__fTimeOutInSeconds = None
     self.__fDefaultTimeOutInSeconds = 600.0
     self.__bIsAbort = False
     # Reference to the object which calls execute or executeSynchronous
     self.__edObject = None
     self.__lExtraTime = [] # list of extra allowed time for execution (in second)
     self.__bLogTiming = False

 def __init__(self, cl, name):
     EDLogging.__init__(self)
     PyTango.Device_4Impl.__init__(self, cl, name)
     self.init_device()
     if isinstance(iNbCpu, int):
         self.screen("Initializing tangoDS with max %i jobs in parallel." % iNbCpu)
         self.__semaphoreNbThreads = threading.Semaphore(iNbCpu)
     else:
         self.__semaphoreNbThreads = threading.Semaphore(EDUtilsParallel.detectNumberOfCPUs())
     self.quit = False
     self.jobQueue = Queue()  # queue containing jobs to process
     self.eventQueue = Queue()  # queue containing finished jobs
     self.statLock = threading.Lock()
     self.lastStatistics = "No statistics collected yet, please use the 'collectStatistics' method first"
     self.lastFailure = "No job Failed (yet)"
     self.lastSuccess = "No job succeeded (yet)"
     self.processingThread = threading.Thread(target=self.startProcessing)
     self.processingThread.start()
     self.finishingThread = threading.Thread(target=self.process_event)
     self.finishingThread.start()