Returns messenger alias.

        :return: str
        :rtype: str
174063
def get_alias(cls):
        
        if cls.alias is None:
            cls.alias = cls.__name__
        return cls.alias
1176467
def get_aliases(lines):
    
    aliases = {}
    for line in lines:
        line = line.strip()
        if len(line) > 0 and line.startswith(SIG_ALIAS):
            _, content = line.split(SIG_ALIAS)
            alias, signature = [t.strip() for t in content.split("=")]
            aliases[alias] = signature
    return aliases
1015171
def get(self, request, bot_id, id, format=None):
                
        return super(MessengerBotDetail, self).get(request, bot_id, id, format)
1371419
def to_array(self):
        
        array = super(ChatActionMessage, self).to_array()
        array['action'] = u(self.action)  # py2: type unicode, py3: type str

        if self.receiver is not None:
            if isinstance(self.receiver, None):
                array['chat_id'] = None(self.receiver)  # type Noneelif isinstance(self.receiver, str):
                array['chat_id'] = u(self.receiver)  # py2: type unicode, py3: type str
            elif isinstance(self.receiver, int):
                array['chat_id'] = int(self.receiver)  # type intelse:
                raise TypeError('Unknown type, must be one of None, str, int.')
            # end if

        return array
1337782
def get_message_urls(self, message_id, order="total_clicks desc"):
        
        req_data = [ { "message_id": str(message_id) }, order, None ]
        return self.request("query:Message_Url", req_data)
1041216
def self(self) -> 'EFBChat':
        
        self.chat_name = "You"
        self.chat_alias = None
        self.chat_uid = EFBChat.SELF_ID
        self.chat_type = ChatType.User
        return self
1290251
def Name(self):
        
        name = ""
        if self.Version:
            name = self.Version.UserAgent
        return name
632047
def aliasstr(self):
		''''''
		return ', '.join(repr(self.ns + x) for x in self.aliases)
1142160
def _get_aliases(self):
        
        """
        if self._aliases is None:
            self._aliases = {}

            if self._xml is not None:
                for child in self._xml.iterchildren():
                    self._aliases[helpers.normalize_tag(child.tag)] = child.tag

        return self._aliases
1016679
def ip_messaging(self):
        
        if self._ip_messaging is None:
            from twilio.rest.ip_messaging import IpMessaging
            self._ip_messaging = IpMessaging(self)
        return self._ip_messaging
1269533
def _get_user(self) -> Dict:
        

        if 'callback_query' in self._update:
            return self._update['callback_query']['from']
        elif 'inline_query' in self._update:
            return self._update['inline_query']['from']
        elif 'message' in self._update:
            return self._update['message']['from']
888599
def aliases(self):
        
        aliases = self.cp.items('aliases')
        alias_dict = dict()

        for alias, meaning in aliases:
            try:
                meaning = shlex.split(meaning)
                real_subcommand = meaning[0]
                alias_args = meaning[1:]
                alias_dict[alias] = (real_subcommand, alias_args)
            except ValueError as verr:
                alias_dict[alias] = str(verr)

        return alias_dict
119013
def _get_pants_target_alias(self, pants_target_type):
    """"""
    if pants_target_type in self.target_aliases_map:
      return self.target_aliases_map.get(pants_target_type)
    else:
      return "{}.{}".format(pants_target_type.__module__, pants_target_type.__name__)
439835
def alias(self):
        
        try:
            return self._properties.Get('org.bluez.Device1', 'Alias')
        except dbus.exceptions.DBusException as e:
            if e.get_dbus_name() == 'org.freedesktop.DBus.Error.UnknownObject':
                # BlueZ sometimes doesn't provide an alias, we then simply return `None`.
                # Might occur when device was deleted as the following issue points out:
                # https://github.com/blueman-project/blueman/issues/460
                return None
            else:
                raise _error_from_dbus_error(e)
1230948
def messages(self):
        
        if self._messages is None:
            self._messages = MessageList(
                self._version,
                service_sid=self._solution['service_sid'],
                channel_sid=self._solution['sid'],
            )
        return self._messages
478202
def get(self, request, bot_id, id, format=None):
        
        return super(MessengerRecipientList, self).get(request, bot_id, id, format)
993805
def _get(self, target, alias):
        
        if target not in self._aliases:
            return
        return self._aliases[target].get(alias)