Initial list of nicknames received - remove op/voice prefixes,
        and send the list to the WebSocket.
482238
def on_namreply(self, connection, event):
        
        for nickname in event.arguments()[-1].split():
            nickname = nickname.lstrip("@+")
            self.nicknames[nickname] = color(nickname)
        self.emit_nicknames()
135593
def _parse_nicknameinuse(client, command, actor, args):
    
    nick, _, _ = args.rpartition(" ")
    client.dispatch_event("NICKNAMEINUSE", nick)
455902
def clean(self):
        
        self.suggest = {
            'input': [' '.join(p) for p in permutations(self.name.split())],
            'weight': self.popularity
        }
434335
function setname(req, res) {
  req.conn.client.name = req.args[0];
  res.send(null, Constants.OK);
}
883149
function getname(req, res) {
  res.send(null, req.conn.client.name);
}
1148964
def rename_to_tmp_name(self):
        
        self.client.rename(
            self.id,
            '%s_%s' % (self.short_id, self.name)
        )
1106908
def _parse_endofnames(client, command, actor, args):
    """"""
    args = args.split(" :", 1)[0] # Strip off human-readable message
    _, _, channel = args.rpartition(' ')
    channel = client.server.get_channel(channel) or channel.lower()
    client.dispatch_event('MEMBERS', channel)
486928
def names(self, channel):
        
        with self.lock:
            self.is_in_channel(channel)

            self.send('NAMES %s' % channel)
            names = []

            while self.readable():
                msg = self._recv(expected_replies=('353', '366'))

                if msg[0] == '353':
                    new_names = msg[2].split()[2:]
                    new_names[0] = new_names[0].replace(':', '', 1)
                    names.extend(new_names)
                elif msg[0] == '366':
                    channel = msg[2].split()[0]
                    break

            for name in names:
                prefix = ''
                if name[0] in self.priv_types:
                    prefix = name[0]
                    name = name[1:]
                if prefix == '~':
                    self.channels[channel]['USERS'][name] = \
                    ['~', '', '', '', '']
                elif prefix == '&':
                    self.channels[channel]['USERS'][name] = \
                    ['', '&', '', '', '']
                elif prefix == '@':
                    self.channels[channel]['USERS'][name] = \
                    ['', '', '@', '', '']
                elif prefix == '%':
                    self.channels[channel]['USERS'][name] = \
                    ['', '', '', '%', '']
                elif prefix == '+':
                    self.channels[channel]['USERS'][name] = \
                    ['', '', '', '', '+']
                else:
                    self.channels[channel]['USERS'][name] = \
                    ['', '', '', '', '']
            return names
1082916
public void refreshNames() {
        Message namesMessage = new Message(MessageType.NAMES, this.channelName);
        List<Message> response;

        try {
            response = connection.request(
                MessageFilters.message(MessageType.RPL_NAMREPLY, null, "=", channelName),
                MessageFilters.message(MessageType.RPL_ENDOFNAMES, null, channelName),
                namesMessage);
        } catch (InterruptedException e) {
            return;
        }

        List<String> names = new ArrayList<String>();

        for (Message message : response) {
            if (message.getType() == MessageType.RPL_NAMREPLY) {
                String[] args = message.getArgs();

                for (String name : args[args.length - 1].split(" ")) {
                    names.add(name.replaceFirst("^[@+]", ""));
                }
            }
        }

        this.names = names;
    }
468293
def make_service_hooks_sync_nickname_action(service):
    
    def sync_nickname(modeladmin, request, queryset):
        for user in queryset:  # queryset filtering doesn't work here?
            service.sync_nickname(user)

    sync_nickname.__name__ = str('sync_{}_nickname'.format(slugify(service.name)))
    sync_nickname.short_description = "Sync nicknames for selected {} accounts".format(service.title)
    return sync_nickname
895025
def _handle_chat_name(self, data):
        """"""

        self.room.user.nick = data
        self.conn.enqueue_data("user", self.room.user)
1183065
def _prepend_name(self, prefix, dict_):
        ''''''
        return dict(['.'.join([prefix, name]), msg]
                    for name, msg in dict_.iteritems())
610349
async def on_isupport_wallchops(self, value):
        
        for prefix, mode in self._nickname_prefixes.items():
            if mode == 'o':
                break
        else:
            prefix = '@'
        self._status_message_prefixes.add(prefix)
479785
def set_name(self, new_name):
        

        yield from self._hypervisor.send('ethsw rename "{name}" "{new_name}"'.format(name=self._name, new_name=new_name))
        log.info('Ethernet switch "{name}" [{id}]: renamed to "{new_name}"'.format(name=self._name,
                                                                                   id=self._id,
                                                                                   new_name=new_name))
        self._name = new_name
171962
def __StripName(self, name):
        """"""
        if not name:
            return name
        for prefix in self.__strip_prefixes:
            if name.startswith(prefix):
                return name[len(prefix):]
        return name
1368183
protected void handleOldNames(List<? extends INode> vdmAst)
			throws AnalysisException
	{
		OldNameRenamer oldNameRenamer = new OldNameRenamer();

		for (INode module : vdmAst)
		{
			module.apply(oldNameRenamer);
		}
	}
737342
def on_nicknameinuse(self, connection, event):
        
        digits = ""
        while self.nickname[-1].isdigit():
            digits = self.nickname[-1] + digits
            self.nickname = self.nickname[:-1]
        digits = 1 if not digits else int(digits) + 1
        self.nickname += str(digits)
        self.connect(self.host, self.port, self.nickname)