喜欢过的话题
        
        :param user_alias: 指定用户，默认当前
        :param start: 翻页
        :return: 带下一页的列表
549171
def list_liked_topics(self, user_alias=None, start=0):
        
        user_alias = user_alias or self.api.user_alias
        xml = self.api.xml(API_GROUP_LIST_USER_LIKED_TOPICS % user_alias, params={'start': start})
        return build_list_result(self._parse_topic_table(xml, 'title,comment,time,group'), xml)
775951
def Alias(self, alias):
        """"""
        # FIXME
        if self.generate_comments:
            self.print_comment(alias)
        print("%s = %s # alias" % (alias.name, alias.alias), file=self.stream)
        self._aliases += 1
        return
1113036
def _validate_alias_name(alias_name):
    
    if not alias_name:
        raise CLIError(EMPTY_ALIAS_ERROR)

    if not re.match('^[a-zA-Z]', alias_name):
        raise CLIError(INVALID_STARTING_CHAR_ERROR.format(alias_name[0]))
850608
def handle_aliases_in_calls(name, import_alias_mapping):
    
    for key, val in import_alias_mapping.items():
        # e.g. Foo == Foo
        # e.g. Foo.Bar startswith Foo.
        if name == key or \
                name.startswith(key + '.'):

            # Replace key with val in name
            # e.g. StarbucksVisitor.Tea -> Eataly.Tea because
            #   "from .nested_folder import StarbucksVisitor as Eataly"
            return name.replace(key, val)
    return None
180957
def create_user(self, user):
        
        self.run("useradd -m %s" % user)
        usr =  getpwnam(user)
        return usr
672687
def users_me(self, include=None, **kwargs):
        ""
        api_path = "/api/v2/users/me.json"
        api_query = {}
        if "query" in kwargs.keys():
            api_query.update(kwargs["query"])
            del kwargs["query"]
        if include:
            api_query.update({
                "include": include,
            })
        return self.call(api_path, query=api_query, **kwargs)
1106697
def user_context(self, worker_ctx, exc_info):
        
        user = {}
        for key in worker_ctx.context_data:
            for matcher in self.user_type_context_keys:
                if re.search(matcher, key):
                    user[key] = worker_ctx.context_data[key]
                    break

        self.client.user_context(user)
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)
912764
def index(self, alias):
        
        clone = self._clone()
        clone._index = alias
        return clone
623715
def get_cassandra_connection(alias=None, name=None):
    

    for _alias, connection in get_cassandra_connections():
        if alias is not None:
            if alias == _alias:
                return connection
        elif name is not None:
            if name == connection.settings_dict['NAME']:
                return connection
        else:
            return connection
134645
def delete_alias(self, using=None, **kwargs):
        
        return self._get_connection(using).indices.delete_alias(index=self._name, **kwargs)
519067
def skips(self, user):
        
        return self._get(self._build_url(self.endpoint.skips(id=user)))
481528
def create_alias(self, userid, data):
        """"""
        return self.api_call(
            ENDPOINTS['aliases']['new'],
            dict(userid=userid),
            body=data)
140964
@Override
    public void start(StartContext startContext) throws StartException {
        try {
            KeyStore keyStore = keyStoreInjector.getValue();
            AliasFilter filter = AliasFilter.fromString(aliasFilter);
            KeyStore unmodifiable = UnmodifiableKeyStore.unmodifiableKeyStore(keyStore);
            KeyStore modifiable = keyStore;

            ROOT_LOGGER.tracef(
                    "starting:  aliasFilter = %s  filter = %s  unmodifiable = %s  modifiable = %s",
                    aliasFilter, filter, unmodifiable, modifiable);

            filteringKeyStore = FilteringKeyStore.filteringKeyStore(unmodifiable, filter);
            if (modifiableFilteringKeyStore == null) {
                modifiableFilteringKeyStore = FilteringKeyStore.filteringKeyStore(modifiable, filter);
            }
        } catch (Exception e) {
            throw new StartException(e);
        }
    }
399450
def get_user(self, user_id=None):
        
        if user_id:
            return self.get('/users/{0}/'.format(user_id))
        return self.get('/users/me/')
683766
def Create(alias=None,location=None,session=None):
		

		if not alias:  alias = clc.v2.Account.GetAlias(session=session)
		if not location:  location = clc.v2.Account.GetLocation(session=session)

		return clc.v2.Requests(
			clc.v2.API.Call('POST','/v2-experimental/networks/%s/%s/claim' % (alias, location),session=session),
			alias=alias,
			session=session)
174063
def get_alias(cls):
        
        if cls.alias is None:
            cls.alias = cls.__name__
        return cls.alias