Python Event.fire方法代码示例

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
 def test_a_listener_is_notified_when_an_event_is_raised(self):
     """"""
     listener = Mock()
     event = Event()
     event.connect(listener)
     event.fire()  
     self.assertTrue(listener.called)

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
 def test_a_listener_is_passed_right_parameters(self):
     """"""
     listener = Mock()
     event = Event()
     event.connect(listener)
     event.fire(5, shape="square")
     listener.assert_called_with(5, shape="square")

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
class World:

  def __init__(self):
    self.connections = []
    self.connection_added = Event()
    self.channel_opened = Event()

  def get_connections(self):
    ret = []
    for c in self.connections:
      ret.append(c)
    return ret

  def remove_connection(self, connection):
    if connection.is_connected:
      raise "I don't think so, tim"
    self.connections.remove(connection)

  def new_connection(self):
    conn = Connection()
    self.connections.append(conn)

    conn.channel_opened += self.handle_channel_opened

    self.connection_added.fire(self, conn)
    return conn

  def shut_it_down(self):
    for c in self.connections:
      c.shut_it_down()

  def handle_channel_opened(self, channel):
    self.channel_opened.fire(self, channel)

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
 def test_Event_SubscribeAndFireWithDupplicateKeyword_RaisesException(self):
     mockListener = mock.Mock()
     event = Event()
     event.subscribe(mockListener, kword1="value1")
 
     with self.assertRaises(DuplicateKeywordArgument):
         event.fire(kword1="value2")

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
 def test_Event_SubscribeWithArgsAndKwargsFireWithArgsAndKwargs_ListenerIsCalledWithMergedArguments(self):
     mockListener = mock.Mock()
     event = Event()
     event.subscribe(mockListener, "arg1", "arg2", kword1="value1", kword2="value2")
 
     event.fire("arg3", "arg4", kword3="value3", kword4="value4")
 
     mockListener.assert_called_with('arg1', 'arg2', 'arg3', 'arg4', kword4='value4', kword3='value3', kword2='value2', kword1='value1')

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
    def test_Event_FireUsingDifferentCallMethod_CallMethodIsCalled(self):
        mock_call_method = mock.Mock()
        event = Event(call_method=mock_call_method)
        event.subscribe("fct1", "arg1")
    
        event.fire("arg2")

        mock_call_method.assert_called_with("fct1", "arg1", "arg2")

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
    def test_Event_UnsubscribeItselfInACallBack_CallbackIsUnsubscribed(self):
        def unsubscriber_callback(event):
            event.unsubscribe(unsubscriber_callback)
        event = Event()
        event.subscribe(unsubscriber_callback, event=event)
    
        event.fire()

        self.assertFalse(event.is_subscribed(unsubscriber_callback))

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
    def test_Event_SubscribeInACallBack_CallbackIsSubscribed(self):
        def subscriber_callback(event, callback2):
            event.subscribe(callback2)
        event = Event()
        event.subscribe(subscriber_callback, event=event, callback2="callback1")
    
        event.fire()

        self.assertTrue(event.is_subscribed("callback1"))

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
class TagReader:
    def __init__(self, connection_string):
        self.clf = nfc.ContactlessFrontend(connection_string)
        self.tag_discovered = Event()
        start_new_thread(self.loop, ())

    def loop(self):
        while True:
            self.clf.connect(rdwr={"on-connect": self.on_connect})

    def on_connect(self, tag):
        self.tag_discovered.fire(tag.identifier.encode("hex"))
        return True

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
class Channel:
  def __init__(self, connection, name):
    self.connection = connection
    self.name = name
    self.getting_names = False
    self.nicks = set()

    self.nick_added = Event()
    self.nick_removed = Event()
    self.nick_changed = Event()
    self.msg_received = Event()
    self.someone_kicked = Event() # Someone, anyone, was kicked from the channel
    self.someone_joined = Event()
    self.someone_parted = Event()
    self.someone_quit = Event()
    self.left = Event() # The pirc user is no longer in the channel

    self.connection.received += self.catch_channel_shit
    self.connection.received += self.catch_joins
    self.connection.received += self.catch_parts
    self.connection.received += self.catch_kicks
    self.connection.received += self.catch_privmsgs
    self.connection.closed += self.catch_connection_closed

    self.connection.nick_changed += self.catch_nick_changed

  def _leave(self):
    for nick in self.nicks.copy():
      self._remove_nick(nick)
    self.left.fire(self)

  def catch_connection_closed(self, msg):
    self._leave()

  def catch_nick_changed(self, (old_nick, new_nick)):
    if old_nick in self.nicks:
      self.nicks.remove(old_nick)
      self.nicks.add(new_nick)
      self.nick_changed.fire(self, old_nick, new_nick)

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
class PrayerTimesNotifier(object):
    def __init__(self, location, alert_on):
        self.praytime = Praytime(location)
        self.waitingfor = getNextPrayer(self.praytime)
        prayername = getPreviousPrayerName(self.waitingfor[0])
        self.now = (prayername, getattr(self.praytime, prayername))
        self.running = False
        self.alarm = Alarm()
        self._ontime = Event()
        self.alert_on = alert_on

    @property
    def onTime(self):
        return self._ontime

    def start(self):
        """
        Start notifying on prayers times
        """
        if self.waitingfor == self.now or not self.running:
            self.waitingfor = getNextPrayer(self.praytime, self.now[0])
            logging.info("Adding alarm %s", self.waitingfor)
            self.alarm.addAlarm(self.waitingfor[1], self._notify, self.waitingfor[0], self.waitingfor[1])
        self.running = True
        return True

    def _notify(self, *args):
        self.now = self.waitingfor
        if self.waitingfor[0] in self.alert_on:
            self._ontime.fire(*args)
        self.start()

    def __str__(self):
        return str(self.praytime)

    def __repr__(self):
        return str(self)

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
class DB(object):
  def __init__(self, settings):
    self.settings = settings
    self.needs_indexing = Event() # fired when the database gets dirtied and needs syncing
    self._pending_indexer = None # non-None if a DBIndexer is running
    self._cur_shard_manager = None # the current DBShardManager object. This has all the DBIndexShards.
    self._cur_query_cache = None

    self._dir_cache = DirCache() # thread only state

    # if we are currently looking for changed dirs, this is the iterator
    # directories remaining to be checked
    self._pending_up_to_date_generator = None

    self.settings.register('dirs', list, [], self._on_settings_dirs_changed)
    self._on_settings_dirs_changed(None, self.settings.dirs)

    self.settings.register('ignores', list, [], self._on_settings_ignores_changed)
    if self.settings.ignores == []:
      self.settings.ignores = DEFAULT_IGNORES;

    self._on_settings_ignores_changed(None, self.settings.ignores)

    self.settings.register('token', str, "", self._on_settings_token_changed)
    self._on_settings_token_changed(None, self.settings.token)

  def close(self):
    if self._cur_shard_manager:
      self._cur_shard_manager.close()
      self._cur_shard_manager = None

  ###########################################################################

  def _on_settings_dirs_changed(self, old, new):
    self._dirs = map(lambda d: DBDir(d), new)
    self._set_dirty()

  @property
  def dirs(self):
    return list(self._dirs)

  def add_dir(self, d):
    real_d = os.path.realpath(d)

    cur = list(self.settings.dirs)
    if real_d in cur:
      raise DBException("Directory %s exists already as %s" % (d, real_d))

    # commit change
    cur.append(real_d)
    self.settings.dirs = cur  # triggers _on_settings_dirs_changed
    return self.dirs[-1]

  def delete_dir(self, d):
    if type(d) != DBDir:
      raise Exception("Expected DBDir")
    cur = list(self.settings.dirs)
    if d.path not in cur:
      raise DBException("not found")
    cur.remove(d.path)
    self.settings.dirs = cur # triggers _on_settings_dirs_changed

  ###########################################################################

  def _on_settings_ignores_changed(self, old, new):
    self._set_dirty()

  @property
  def ignores(self):
    return list(self.settings.ignores)

  def ignore(self,pattern):
    i = list(self.settings.ignores)
    if pattern in i:
      return
    i.append(pattern)
    self.settings.ignores = i

  def unignore(self,pattern):
    i = list(self.settings.ignores)
    i.remove(pattern)
    self.settings.ignores = i

  ###########################################################################

  def _on_settings_token_changed(self, old, new):
    self._set_dirty()

  @property
  def token(self):
    return self.settings.token

  @token.setter
  def token(self, token):
    self.settings.token = token

  ###########################################################################

  @property
  def has_index(self):
#.........这里部分代码省略.........

# 需要导入模块: from event import Event [as 别名]
# 或者: from event.Event import fire [as 别名]
class NetworkNode(object):
    
    MAX_REQUEST_ID = 1000000
    """ keep track of requests send to other nodes """
    def __init__(self, network_handler, random=SystemRandom()):
        self.network_handler = network_handler
        self.requests_sent = {}
        self.requests_received = {}
        self.addr = self.network_handler.getaddr()
        self.network_handler.ON_MESSAGE.subscribe(self._on_message)
        self.random = random
        self.ON_REQUEST = Event()
    
    def find_unique_requestid(self):
        result_id = self.random.randint(0, self.MAX_REQUEST_ID)
        while result_id in self.requests_sent:
            result_id = self.random.randint(0, self.MAX_REQUEST_ID)
        return result_id

    def request(self, addr, request):
        id = self.find_unique_requestid()
        f = Future()
        self.requests_sent[id] = (f, request)
        self._send_request(addr, request, id)
        return f

    def reply(self, reply_future):
        try:
            result = reply_future.result()
        except:
            traceback.print_exc()
        from_addr, request, id = self.requests_received[reply_future] 
        self._send_reply(from_addr, result, id)
    
    def _send_request(self, addr, request, id):
        data = json.dumps({"request": request, "id": id})
        self.network_handler.send(addr, data)

    def _send_reply(self, addr, reply, id):
        data = json.dumps({"reply": reply, "id": id})
        self.network_handler.send(addr, data)
        
    def _on_message(self, from_addr, data):
        data = json.loads(data)
        if "request" in data:
            reply_future = Future()
            self.requests_received[reply_future] = (from_addr, data["request"], data.get("id"))
            self.ON_REQUEST.fire(reply_future, from_addr, data["request"], id)
            reply_future.add_done_callback(self.reply)
            #then(reply_future, self.reply)
        if "reply" in data:
            if "id" not in data:
                print "error: missing 'id' in reply"
                return
            if not (isinstance(data["id"], basestring) or type(data["id"]) is int):
                print "error: 'id' should be an int or a string"
                return
            if data["id"] not in self.requests_sent:
                print self.requests_sent
                print data["id"]
                print "error: unknown 'id'"
                return
            future, request = self.requests_sent[data["id"]]
            future.set_result(data["reply"])