Python observable.Observable类代码示例

 def __init__(self, config):
     self._config = config
     self._mame = None
     self._connection = None
     self._running = False
     Observable.__init__(self)
     threading.Thread.__init__(self)

    def __init__(self, app=None):
        Observable.__init__(self)
        self.app = None
        self.resources = {}

        if app is not None:
            self.init_app(app)

 def __init__(self):
     self.Name = Observable(None)
     self.FullPath = Observable(None)
     self.Magic = Observable(None)
     self.Format = Observable(None)
     self.Directory = Observable(None)
     self.Magic.addCallback(self,self.OnMagic)

 def subscribe(self, *args, **keys):
     Observable.subscribe( self, *args, **keys )
     if self.dirty:
         self._notifyDirty()
 #
 #def _getRecursiveDirty(self):
 #    if self.dirty:
 #        return True
 #    
 #    for name, value in vars(self).items():
 #        if hasattr(name, 'dirty'):
 #            if value.recursiveDirty:
 #                return True
 #    
 #    return False
 #
 #def _setRecursiveDirty(self, dirtyValue):
 #    for name in self.observer_attribs:
 #        value = getattr(self, name)
 #        try:
 #            value.recursiveDirty = dirtyValue
 #        except AttributeError:
 #            pass
 #        #value.dirty = False
 #        pass
 #            
 #    self.dirty = dirtyValue
 #
 #recursiveDirty = property( _getRecursiveDirty, _setRecursiveDirty )

    def __init__(self, trigger, func, args, kwargs, misfire_grace_time,
                 coalesce, name=None, max_runs=None, max_instances=1, active=True):
        Observable.__init__(self)
        if not trigger:
            raise ValueError('The trigger must not be None')
        if not hasattr(func, '__call__'):
            raise TypeError('func must be callable')
        if not hasattr(args, '__getitem__'):
            raise TypeError('args must be a list-like object')
        if not hasattr(kwargs, '__getitem__'):
            raise TypeError('kwargs must be a dict-like object')
        if misfire_grace_time <= 0:
            raise ValueError('misfire_grace_time must be a positive value')
        if max_runs is not None and max_runs <= 0:
            raise ValueError('max_runs must be a positive value')
        if max_instances <= 0:
            raise ValueError('max_instances must be a positive value')


        self._lock = Lock()
        self.trigger = trigger
        self.func = func
        self.args = args
        self.kwargs = kwargs
        self.name = to_unicode(name or get_callable_name(func))
        self.misfire_grace_time = misfire_grace_time
        self.coalesce = coalesce
        self.max_runs = max_runs
        self.max_instances = max_instances
        self.runs = 0
        self.instances = 0
        self.active = active

    def __init__(self,id_scan,nom_unique,type_scan,chemin_rapport,liste_adresses,nmap_options=None,nessus_policy_id=None):
        Observable.__init__(self)
        self.nmap={'enable':False,'options':None,'instance':None,'status':'disable','progress':0,'import':'disable'}
        self.nessus={'enable':False,'id':-1,'policy_id':None,'status':'disable','progress':0,'import':'disable'}
        self.erreurs=[]
        self.cibles=liste_adresses
        self.nom_unique=nom_unique
        self.chemin_rapport=chemin_rapport
        self.id_scan=id_scan
        self.tache_attente=[]
        self.compteur_erreur_nessus=0
        self.type_scan=type_scan

        if nmap_options!=None:
            self.nmap['enable']=True
            self.nmap['options']=nmap_options
            self.nmap['status']='ready'
            self.nmap['import']='ready'
            self.nmap['instance']=scanNmap(self.cibles,self.nmap['options'],CHEMIN_TEMP+'nmap/'+str(self.nom_unique)+'.xml')


        if nessus_policy_id!=None:
            self.nessus['enable']=True
            self.nessus['policy_id']=nessus_policy_id
            self.nessus['status']='ready'
            self.nessus['import']='ready'

    def __init__(self, tableau_adresse, options, fichier_sortie):
        Thread.__init__(self)
        Observable.__init__(self)
        self.adresse = ""
        self.progress = 0.0
        self.status = "ready"

        # On cree un string a partir de la liste des adresses
        # contenues dans le tableau
        for ip in tableau_adresse:
            try:
                ip = valideIP(ip)
                self.adresse += " " + str(ip)
            except:
                pass

        liste_arguments = [options, fichier_sortie]

        # Contrôle des arguments
        for arg in liste_arguments:
            error = re.search('[;|<>"`&{}]', str(arg))

            if error != None:
                raise Exception("Paramètres Nmap invalide")

        # Si pas de levé d'exception
        self.options = options
        self.fichier_sortie = fichier_sortie

	def __init__(self, network_interface, src_ip, target_ip):
		Observable.__init__(self)
		Executable.__init__(self, self.ping_executable)
		self.network_interface = network_interface
		self.src_ip = src_ip
		self.target_ip = target_ip
		print "# Setting up loop for pinging " + target_ip + " (with " + src_ip + " on " + network_interface + ") "

    def __init__(self, config, environ, logger, statechglogger):
        Observable.__init__(self)
        self.config = config
        self.environ = environ
        self.statechglogger = statechglogger
        self.logdispatch = logger
        self.rulenumber = 0
        self.rulename = 'template class'
        self.mandatory = False
        self.helptext = """This is the default help text for the base rule
class. If you are seeing this text it is because the developer for one of the
rules forgot to assign the appropriate help text. Please file a bug against
LANL-stonix."""
        self.executionpriority = 50
        self.rootrequired = True
        self.configinsimple = False
        self.detailedresults = """This is the default detailed results text
        for the base rule class. If you are seeing this text it is because the
        developer for one of the rules forgot to assign the appropriate text.
        Please file a bug against stonix."""
        self.compliant = False
        self.rulesuccess = True
        self.databaserule = False
        self.applicable = {'default': 'default'}
        self.revertable = False
        self.confitems = []
        self.currstate = "notconfigured"
        self.targetstate = "configured"
        self.guidance = []

 def __init__(self, environment):
     Observable.__init__(self)
     self.environment = environment
     self.debug = self.environment.getdebugmode()
     self.verbose = self.environment.getverbosemode()
     self.constsrequired = [localize.REPORTSERVER,
                            localize.STONIXDEVS,
                            localize.STONIXERR,
                            localize.MAILRELAYSERVER]
     reportfile = 'stonix-report.log'
     xmlfile = 'stonix-xmlreport.xml'
     self.logpath = self.environment.get_log_path()
     self.reportlog = os.path.join(self.logpath, reportfile)
     self.xmllog = os.path.join(self.logpath, xmlfile)
     if self.debug:
         print 'LOGDISPATCHER: xml log path: ' + self.xmllog
     if os.path.isfile(self.xmllog):
         try:
             if os.path.exists(self.xmllog + '.old'):
                 os.remove(self.xmllog + '.old')
             move(self.xmllog, self.xmllog + '.old')
         except (KeyboardInterrupt, SystemExit):
             # User initiated exit
             raise
         except Exception, err:
             print 'logdispatcher: '
             print traceback.format_exc()
             print err

class QuackCounter(Quackable):

    number_of_quacks = 0

    def __init__(self, quackable):
        self._quackable = quackable
        self._observable = Observable(self)

    def __repr__(self):
        return repr(self._quackable)

    def quack(self):
        self._quackable.quack()
        QuackCounter.number_of_quacks += 1
        self.notify_observers()

    def register_observer(self, observer):
        self._observable.register_observer(observer)

    def notify_observers(self):
        self._observable.notify_observers()

    @classmethod
    def get_quacks(cls):
        return cls.number_of_quacks

def test_no_event_for_trigger():
    """test exception raising for not existing events"""
    obs = Observable()

    assert not obs.trigger("no_existing_event")

    with pytest.raises(EventNotFound):
        obs.off("no_existing_event")

 def refresh_play_status(self):
     logger.debug("refresh_playing_status")
     try:
         status = self.get_status()
         if 'state' in status:
             self.play_status = status['state']
         Observable.notify_toggle_observers(self, {'status': self.play_status})
     except mpd.ConnectionError:
         logger.error('Lost connection on get get_playing_status')

def test_on():
    """test event registering with the on method"""
    obs = Observable()

    def on_test():
        pass

    obs.on("on_test", on_test)
    assert on_test in obs._events["on_test"]

def test_trigger_arg():
    """test event triggering with arguments"""
    obs = Observable()

    @obs.on("some_test")
    def some_test(some_data):
        assert some_data == "some data"

    assert obs.trigger("some_test", "some data")