Get aliases information from room state.

        Returns:
            boolean: True if the aliases changed, False if not
173488
def update_aliases(self):
        
        try:
            response = self.client.api.get_room_state(self.room_id)
            for chunk in response:
                if "content" in chunk and "aliases" in chunk["content"]:
                    if chunk["content"]["aliases"] != self.aliases:
                        self.aliases = chunk["content"]["aliases"]
                        return True
                    else:
                        return False
        except MatrixRequestError:
            return False
326204
function() {
            self._client.roomState(roomId).then(function(events) {
                events.forEach(function(ev) {
                    if (self._eventTypes[ev.type]) {
                        if (!r.events[ev.type]) {
                            r.events[ev.type] = {};
                        }
                        r.events[ev.type][ev.state_key] = ev;
                    }
                });
                resolve(r);
            }, function(err) {
                if (err.httpStatus >= 400 && err.httpStatus < 600) { // 4xx, 5xx
                    reject(err); // don't have permission, don't retry.
                }
                // wait a bit then try again
                Promise.delay(3000).then(function() {
                    if (!self._dict[roomId]) {
                        return;
                    }

                    queryRoomState();
                });
            });
        }
222368
def get_room_id(self, room_alias):
        
        content = self._send("GET", "/directory/room/{}".format(quote(room_alias)))
        return content.get("room_id", None)
212803
def get_child_ids(self, parent_alias):
        
        self._cache_init()
        return self._cache_get_entry(self.CACHE_NAME_PARENTS, parent_alias, [])
157490
def do_get_aliases(name):
  
  metric_schemas = MetricSchemas()
  aliases = metric_schemas.get_aliases(name)
  for alias in aliases:
    do_print(alias)
81128
def get_alias_table():
    
    try:
        alias_table = get_config_parser()
        alias_table.read(azext_alias.alias.GLOBAL_ALIAS_PATH)
        return alias_table
    except Exception:  # pylint: disable=broad-except
        return get_config_parser()
345258
def sort_aliases(self, aliases):
        
        self._cache_init()
        if not aliases:
            return aliases
        parent_aliases = self._cache_get_entry(self.CACHE_NAME_PARENTS).keys()
        return [parent_alias for parent_alias in parent_aliases if parent_alias in aliases]
924133
def get_from_relations(self, query,aliases):
        '''
        
        '''
        return [aliases[rel.get_name()] for rel in query.get_relations() if not rel.is_negated()]
786096
def get_by_name(self, name, alias=None):
        """"""
        search_filter = "[?name=='{}']".format(name)

        if alias:
            if self.version == 1:
                search_filter = "accounts[?name=='{name}' || contains(alias, '{name}')]".format(name=name)

            elif self.version == 2:
                search_filter = "[?name=='{name}' || contains(aliases, '{name}')]".format(name=name)

        return self.get_all(search_filter)
608378
def get_alias(self, alias):
        
        alias = alias or {}
        return [k for k, v in alias.items() if self.mnemonic in v]
621511
def aliases(self):
        """"""
        return {alias.namespace: alias.name for alias in self._proto.alias}.items()
104124
def get_room_info(self, room_ids):
        
        try:
            resp = self._request("GET", "/1.1/space/item/{}".format(room_ids))
            rooms = resp.json()
            for room in rooms:
                if not room["image"].startswith("http"):
                    room["image"] = "https:" + room["image"]

                if "description" in room:
                    description = room["description"].replace(u'\xa0', u' ')
                    room["description"] = BeautifulSoup(description, "html.parser").text.strip()
        except resp.exceptions.HTTPError as error:
            raise APIError("Server Error: {}".format(error))
        return rooms
227888
def refresh_rooms(self):
        """"""
        for room_id in self.user_api.get_joined_rooms()["joined_rooms"]:
            self._rooms[room_id] = MatrixRoom(room_id, self.user_api)
459769
def get_rooms(self, sid, namespace):
        """"""
        r = []
        try:
            for room_name, room in six.iteritems(self.rooms[namespace]):
                if room_name is not None and sid in room and room[sid]:
                    r.append(room_name)
        except KeyError:
            pass
        return r
200816
def _getAlias(self, auth_level_uri):
        
        for (alias, existing_uri) in self.auth_level_aliases.iteritems():
            if auth_level_uri == existing_uri:
                return alias

        raise KeyError(auth_level_uri)
196555
def [](id)
      return @rooms[id] if id.start_with? '!'

      if id.start_with? '#'
        res = @rooms.find { |_, r| r.canonical_alias == id }
        return res.last if res.respond_to? :last
      end

      res = @rooms.find { |_, r| r.name == id }
      res.last if res.respond_to? :last
    end
1029733
def resolve_aliases(self, chunks):
        '''
        
        '''
        for idx, _ in enumerate(chunks):
            new_state = self.aliases.get(chunks[idx]['state'])
            if new_state is not None:
                chunks[idx]['state'] = new_state