Python WeakKeyDictionary.iterkeys方法代码示例

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import iterkeys [as 别名]
class NumberShiftMultiplexer(_internal.NumberShiftListener):
    def __init__(self, name=None):
        _internal.NumberShiftListener.__init__(self)
        from weakref import WeakKeyDictionary
        self.subscribers = WeakKeyDictionary()
        self.name = name

    def subscribe(self, subscriber):
        self.subscribers[subscriber] = None

    def note_change_size(self, new_size):
        for subscriber in self.subscribers.iterkeys():
            subscriber.note_change_size( new_size)

    def note_move(self, orig, dest, size):
        for subscriber in self.subscribers.iterkeys():
            subscriber.note_move(orig, dest, size)

    def note_reset(self, start, size):
        for subscriber in self.subscribers.iterkeys():
            subscriber.note_reset(start, size)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import iterkeys [as 别名]
class StatePassingNumberShiftMultiplexer(NumberShiftMultiplexer):
    def __init__(self, state):
        NumberShiftMultiplexer.__init__(self)
        from weakref import WeakKeyDictionary
        self.subscribers_with_state = WeakKeyDictionary()
        self.state = state

    def subscribe_with_state(self, subscriber):
        self.subscribers_with_state[subscriber] = None

    def note_change_size(self, new_size):
        NumberShiftMultiplexer.note_change_size(self, new_size)
        for subscriber in self.subscribers_with_state.iterkeys():
            subscriber.note_change_size(self.state, new_size)

    def note_move(self, orig, dest, size):
        NumberShiftMultiplexer.note_move(self, orig, dest, size)
        for subscriber in self.subscribers_with_state.iterkeys():
            subscriber.note_move(self.state, orig, dest, size)

    def note_reset(self, start, size):
        NumberShiftMultiplexer.note_move(self, start, size)
        for subscriber in self.subscribers_with_state.iterkeys():
            subscriber.note_reset(self.state, start, size)

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import iterkeys [as 别名]
class IRCChannel(object):
	def __init__(self, ircd, name):
		if not isValidChannelName(name):
			raise InvalidChannelNameError
		self.ircd = ircd
		self.name = name[:self.ircd.config.get("channel_name_length", 64)]
		self.users = WeakKeyDictionary()
		self.modes = {}
		self.existedSince = now()
		self.topic = ""
		self.topicSetter = ""
		self.topicTime = now()
		self._metadata = CaseInsensitiveDictionary()
		self.cache = {}
	
	def sendUserMessage(self, command, *params, **kw):
		"""
		Sends a message to all local users in a channel.
		Accepts a command and some parameters for that command to send.
		Accepts any keyword arguments accepted by IRCUser.sendMessage.
		Also accepts the following keyword arguments:
		- skip: list of users in the channel to skip when sending the message
		"""
		if "to" not in kw:
			kw["to"] = self.name
		if kw["to"] is None:
			del kw["to"]
		userList = [u for u in self.users.iterkeys() if u.uuid[:3] == self.ircd.serverID]
		if "skip" in kw:
			for u in kw["skip"]:
				if u in userList:
					userList.remove(u)
		kw["users"] = userList
		kw["channels"] = [self]
		baseTags = {}
		if "tags" in kw:
			baseTags = kw["tags"]
			del kw["tags"]
		conditionalTags = {}
		if "conditionalTags" in kw:
			conditionalTags = kw["conditionalTags"]
			del kw["conditionalTags"]
		for user in userList:
			if conditionalTags:
				tags = baseTags.copy()
				addTags = user.filterConditionalTags(conditionalTags)
				tags.update(addTags)
			else:
				tags = baseTags
			kw["tags"] = tags
			user.sendMessage(command, *params, **kw)
	
	def sendServerMessage(self, command, *params, **kw):
		"""
		Sends a message to all remote servers to which any user in this channel
		is connected. Accepts a command and some parameters for that command to
		send. Also accepts the following keyword arguments:
		- skipall: list of servers to skip from the network
		- skiplocal: list of locally-connected servers to which to skip sending
		    after we've determined the closest hop of all the servers to which
		    we're sending
		"""
		servers = set()
		for user in self.users.iterkeys():
			if user.uuid[:3] != self.ircd.serverID:
				servers.add(self.ircd.servers[user.uuid[:3]])
		if "skipall" in kw:
			for s in kw["skipall"]:
				servers.discard(s)
		localServers = set()
		for server in servers:
			nearHop = server
			while nearHop.nextClosest != self.ircd.serverID:
				nearHop = self.ircd.servers[nearHop.nextClosest]
			localServers.add(nearHop)
		if "skiplocal" in kw:
			for s in kw["skiplocal"]:
				localServers.discard(s)
		for server in localServers:
			server.sendMessage(command, *params, **kw)
	
	def setTopic(self, topic, setter):
		"""
		Sets the channel topic.
		"""
		if setter in self.ircd.users:
			source = self.ircd.users[setter].hostmask()
		elif setter == self.ircd.serverID:
			source = self.ircd.name
		elif setter in self.ircd.servers:
			source = self.ircd.servers[setter].name
		else:
			return False
		if topic == self.topic:
			return True
		oldTopic = self.topic
		self.topic = topic
		self.topicSetter = source
		self.topicTime = now()
		self.ircd.runActionStandard("topic", self, setter, oldTopic, channels=[self])
#.........这里部分代码省略.........

# 需要导入模块: from weakref import WeakKeyDictionary [as 别名]
# 或者: from weakref.WeakKeyDictionary import iterkeys [as 别名]
class GameServer(Server):
    channelClass = ClientChannel
    ADDED = 1
    HANDSHAKEN = 2
    AUTHED = 3
    def __init__(self, *args, **kwargs):
        Server.__init__(self, *args, **kwargs)
        self.players = WeakKeyDictionary()
        self.done = False
        print 'Server launched'
    
    def Connected(self, channel, addr):
        self.players[channel] = self.ADDED
        channel.dataAllowedPerSecond = 100000 # Adjust these to control how much amount of data that can be sent per second
        channel.dataAllowedPer30Second = 1000000 # per 30 seconds. if data amount sent is not under the limit, it will disconnect the client
        channel.Send({"action": "handshake", "msg": "ITEMDIGGERS PING %s" % shared.VERSION})

    def Tick(self, tick):
        for p in self.players:
            p.Tick(tick)
    def DelPlayer(self, player):
        #print "Deleting Player" + str(player.addr)
        del self.players[player]

    """
        self.AddPlayer(channel)
    
    def AddPlayer(self, player):
        print "New Player" + str(player.addr)
        self.players[player] = True
        self.SendPlayers()
        print "players", [p for p in self.players]
    
    def DelPlayer(self, player):
        print "Deleting Player" + str(player.addr)
        del self.players[player]
        self.SendPlayers()
    
    def SendPlayers(self):
        self.SendToAll({"action": "players", "players": [p.nickname for p in self.players]})
    
    def SendToAll(self, data):
        [p.Send(data) for p in self.players]
    """
    
    def Launch(self):
        clockPrev = time.clock()
        clockEnd = time.clock()
        while not self.done:
            tick = (clockEnd-clockPrev)*1000
            clockPrev = time.clock()
            time.clock()
            self.Pump()
            self.Tick(tick)

            for p in self.players.iterkeys():
                p.moveW += tick
                p.skillW += tick

            sleep(0.001)
            clockEnd = time.clock()